,\n // so

alone still leaks furniture into the text Jev reads.\n // (No backticks in this comment: it lives inside a template literal.)\n const root = document.querySelector(\n 'article, #mw-content-text, [role=\"main\"], main, #content'\n ) || document.body;\n\n return {\n url: location.href,\n title: document.title,\n text: (root.innerText || '').replace(/\\\\s+/g, ' ').trim().slice(0, ${TEXT_CHARS}),\n candidates: found,\n };\n});\n// Browser history IDs distinguish a real Back destination from an arbitrary\n// previously seen URL, including same-document history entries.\nlet cdp;\ntry {\n cdp = await page.context().newCDPSession(page);\n const history = await cdp.send(\"Page.getNavigationHistory\");\n const current = history.entries[history.currentIndex];\n const previous = history.entries[history.currentIndex - 1];\n if (current && current.url === raw.url) {\n raw.navigation = {\n currentId: current.id,\n previous: previous ? { id: previous.id, url: previous.url } : undefined,\n };\n }\n} catch {\n // If history cannot be read, ordinary actions work and Back is unavailable.\n} finally {\n if (cdp) await cdp.detach().catch(() => {});\n}\nreturn raw;\n`;\n\ntype RawPage = {\n url: string;\n title: string;\n text: string;\n candidates: Omit[];\n navigation?: PageState[\"navigation\"];\n};\n\n/** Read the current page as data. */\nexport async function perceive(sessionId: string, includeNavigation = true): Promise {\n const res = await runPlaywright(sessionId, PERCEIVE);\n if (!res.success) {\n throw new Error(res.error || \"could not read the page\");\n }\n const raw = res.result as RawPage;\n return {\n url: raw?.url ?? \"\",\n title: raw?.title ?? \"\",\n navigation: raw?.navigation,\n text: raw?.text ?? \"\",\n // `n` is assigned here rather than in the browser: it's the key Jev's\n // answers come back under, so it has to be stable and sequential. `dom`\n // keeps pointing at the element.\n candidates: selectCandidates(raw?.candidates ?? [], MAX_ELEMENTS).map((c, n) => ({ ...c, n })),\n };\n}\n\n/**\n * Scroll an element into view and report where to click it.\n *\n * Coordinates measured during `perceive()` are a Jev round trip old by the time\n * we click, and for anything below the fold they aren't even on screen. Asking\n * the browser where the element is *now* fixes both.\n *\n * Everything must happen inside `page.evaluate`. This snippet runs in Kernel's\n * Node VM, where `document` and `window` don't exist — only `page` does. An\n * earlier version called `document.querySelector` directly, so every call threw\n * and the click fell back to stale coordinates; the page never changed and Jev\n * picked the same control again, step after step.\n *\n * The target is the middle of the element **and** the viewport, not the middle\n * of the element. `scrollIntoView({block: 'center'})` cannot centre an element\n * taller than the viewport, so its own midpoint can sit off-screen — and Kernel\n * answers an out-of-bounds coordinate with a 400 rather than clamping it.\n * Returns null when the two don't overlap at all.\n */\nfunction locate(dom: number): string {\n return `\nreturn await page.evaluate(async (d) => {\n const el = document.querySelector('[data-jev=\"' + d + '\"]');\n if (!el) return null;\n el.scrollIntoView({ block: 'center', behavior: 'auto' });\n await new Promise((resolve) => setTimeout(resolve, 150));\n const r = el.getBoundingClientRect();\n const W = window.innerWidth - 1;\n const H = window.innerHeight - 1;\n const left = Math.max(0, Math.min(r.left, W));\n const right = Math.max(0, Math.min(r.right, W));\n const top = Math.max(0, Math.min(r.top, H));\n const bottom = Math.max(0, Math.min(r.bottom, H));\n if (right < left || bottom < top) return null;\n return { x: Math.round((left + right) / 2), y: Math.round((top + bottom) / 2) };\n}, ${dom});\n`;\n}\n\n/** Keep a coordinate inside the screen, whatever the browser reported. */\nfunction clamp(n: number, max: number): number {\n return Math.max(0, Math.min(max, Math.round(n)));\n}\n\n/** How long to let a click settle before reading the page again. */\nconst SETTLE_MS = 1200;\n\n/**\n * Carry out one decision.\n *\n * Clicking always moves the cursor first. That's not just for the video — a\n * bare click at coordinates the cursor never visited is the kind of thing\n * hover-sensitive menus ignore.\n */\nexport async function act(sessionId: string, decision: Decision): Promise {\n if (decision.action === \"back\") {\n if (!decision.back) throw new Error(\"Back has no verified destination\");\n const result = await runPlaywright(sessionId, backScript(decision.back), 15);\n if (!result.success) throw new Error(result.error || \"Back failed\");\n await sleep(SETTLE_MS);\n return;\n }\n const target = decision.target;\n if (!target) return;\n\n const located = await runPlaywright(sessionId, locate(target.dom));\n if (!located.success) {\n throw new Error(\n `could not locate the control to click: ${located.error ?? \"unknown\"}`,\n );\n }\n const at = located.result as { x: number; y: number } | null;\n // Deliberately no fallback to the coordinates perceive() measured. They are a\n // Jev round trip stale, and for anything below the fold they were never on\n // screen at all — clicking them lands somewhere arbitrary, the page doesn't\n // change, and Jev picks the same control again next step. Failing loudly is\n // what makes that visible instead of silent.\n if (!at) {\n throw new Error(`\"${target.label}\" is no longer on the page`);\n }\n const x = clamp(at.x, VIEWPORT.width - 1);\n const y = clamp(at.y, VIEWPORT.height - 1);\n\n await moveMouse(sessionId, x, y, 420);\n await clickMouse(sessionId, x, y);\n\n if (decision.action === \"type\" && decision.text) {\n await sleep(250);\n await typeText(sessionId, decision.text);\n // Enter is the assumption: a field we chose to type into is nearly always\n // a search box or a form's only input. A field that needs a separate\n // submit click gets one on the next step.\n await pressKey(sessionId, [\"Enter\"]);\n }\n\n await sleep(SETTLE_MS);\n}\n\n/** Recheck immediately before Back; navigation may have changed during the model call. */\nfunction backScript(back: NonNullable): string {\n return `\nconst expected = ${JSON.stringify(back)};\nconst cdp = await page.context().newCDPSession(page);\ntry {\n const before = await cdp.send(\"Page.getNavigationHistory\");\n const current = before.entries[before.currentIndex];\n const previous = before.entries[before.currentIndex - 1];\n if (current?.id !== expected.fromEntryId || previous?.id !== expected.entryId || previous?.url !== expected.url) {\n throw new Error(\"Browser history changed; Back cancelled\");\n }\n // A null response is valid for same-document navigation, so verify the entry.\n await page.goBack({ waitUntil: \"domcontentloaded\", timeout: 8000 });\n const after = await cdp.send(\"Page.getNavigationHistory\");\n if (after.entries[after.currentIndex]?.id !== expected.entryId) {\n throw new Error(\"Back did not reach the expected history entry\");\n }\n return { url: page.url() };\n} finally {\n await cdp.detach();\n}\n`;\n}\n\n/** One line describing what happened, for the step log and Jev's own history. */\nexport function describeAction(decision: Decision): string {\n if (decision.action === \"back\") return `go back to ${decision.back?.url ?? \"previous page\"}`;\n if (decision.action === \"done\") return \"stop — goal reached\";\n if (decision.action === \"stuck\") return \"stop — no useful untried action\";\n const target = decision.target;\n const what = target ? `\"${target.label}\"` : \"nothing\";\n return decision.action === \"type\"\n ? `type \"${decision.text}\" into ${what}`\n : `click ${what}`;\n}","createdAt",["D",1789605887418],"branchVersion","branchId","789b925f-1f04-4496-b61e-c55aa361585d","id","3c438ea3-80e8-4cac-9708-6511f055598d","jev-browser-use",["D",1789588833583],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","restricted","description","Describe a task; Jev decides each step in a KERNEL cloud browser","imageUrl","https://imagedelivery.net/iHX6Ovru0O7AjmyT5yZRoA/601425b5-d08c-486a-cae2-cbfbdf0cc801/square512?exp=1789611035&sig=c10c9d4064ea93c7d2fa88dc6154ae9eea350fe0aeb9ad0dae28ae5783e6b7fd","a0bf3b31-15a5-4d5c-880e-4b1e22c9bc18","pinnedFileId","01a0abce-8571-76e1-8061-dc657cf63b40","pinPreview",true,"pinMigrated","screenshotVersion","likeCount",0,"orgId","b2fd4880-5c2e-11f0-9801-5764bf98a432","tursoName","3c438ea380e84cac97086511f055598d","tursoHostname","3c438ea380e84cac97086511f055598d-val-town.aws-us-east-2.turso.io","tursoMeasuredAt",["D",1789590099209],"pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_106":105,"_114":110},"org",{"_106":105,"_107":108,"_109":110,"_18":-5,"_111":112,"_113":61},"branch",{"_13":91,"_32":92,"_43":42,"_93":44,"_94":95,"_96":97,"_98":50,"_99":100,"_101":102,"_103":45,"_104":105},"isOwned",280,"main","projectId","forkedBranchId","e9a8eeca-33f2-423b-8459-435fd862f66d","forkedBranchVersion",74,"forkedProjectPrivacy","forkedProjectId","c242175a-bb41-49a1-ae69-d9c2930a22f1","forkedProjectOrgId","e81e7335-6d4c-4764-a902-d0962bbfa9f7","projectName","userHandle","kernel","handle","displayName","KERNEL","avatar","https://imagedelivery.net/iHX6Ovru0O7AjmyT5yZRoA/772b82b9-bcf2-4ee8-2b88-3bbabc7f9801/square512?exp=1789611035&sig=0ad69e908e6330861af48d44172db1821f9e64f2b424f1a0e6c799625ff98c2b","tier","business","canRestrictVals","profileImageUrl","branchName","","adoptOrgId",{"_43":44,"_32":45,"_38":450,"_47":-5,"_48":25,"_49":50,"_51":52,"_53":54,"_55":56,"_18":57,"_58":59,"_60":61,"_62":-5,"_63":-5,"_64":65,"_66":67,"_68":69,"_70":71,"_72":451,"_74":-5,"_75":76,"_77":76,"_78":79,"_80":79,"_81":79,"_82":76,"_83":76,"_84":452,"_86":453,"_88":454,"_90":25},"tree",[268,277,285,286,287,288,289,290,291,292,293,294,295],"files",[268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295],"counts",{"_258":65,"_259":166,"_260":65,"_261":262,"_263":264},"contents",[149,150,151,152,153,154,155,156,157,158,159,160,161],"upstreamProject",{"_43":100,"_32":145,"_53":146,"_55":-5,"_49":50,"_84":147},"upstreamBranch",{"_43":95,"_38":139,"_140":141,"_32":92,"_93":100,"_13":97,"_94":-5,"_96":-5,"_142":143,"_47":-5,"_90":25,"_49":50,"_104":144,"_66":102,"_103":145},"emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},["D",1789580290788],"updatedAt",["D",1789591366294],"lockfileKey","1789591367061-esm.town_v_stevekrouse_typesafe-typewriter@74-main","stevekrouse","typesafe-typewriter","16 TypeSafe gut-checks on your writing, on every keystroke",{"_106":144,"_114":148},"https://images.clerk.dev/uploaded/img_2PqHa2Gsy93xQrjh2w78Xu0cChW.jpeg",{"_43":253,"_32":254,"_30":255,"_165":-5,"_41":42,"_40":166,"_167":61,"_38":256,"_13":65,"_33":251,"_35":-5,"_24":25,"_170":-5,"_27":257},{"_43":247,"_32":248,"_30":249,"_165":-5,"_41":42,"_40":166,"_167":61,"_38":250,"_13":65,"_33":251,"_35":-5,"_24":25,"_170":-5,"_27":252},{"_43":239,"_32":240,"_30":241,"_165":-5,"_41":42,"_40":242,"_167":25,"_38":243,"_13":244,"_33":20,"_35":245,"_24":25,"_170":-5,"_27":246},{"_43":231,"_32":232,"_30":233,"_165":-5,"_41":42,"_40":234,"_167":25,"_38":235,"_13":236,"_33":20,"_35":237,"_24":25,"_170":-5,"_27":238},{"_43":227,"_32":28,"_30":31,"_165":-5,"_41":42,"_40":14,"_167":25,"_38":228,"_13":229,"_33":34,"_35":37,"_24":25,"_170":-5,"_27":230},{"_43":220,"_32":221,"_30":222,"_165":-5,"_41":42,"_40":223,"_167":61,"_38":224,"_13":185,"_33":34,"_35":225,"_24":25,"_170":-5,"_27":226},{"_43":212,"_32":213,"_30":214,"_165":-5,"_41":42,"_40":215,"_167":61,"_38":216,"_13":217,"_33":34,"_35":218,"_24":25,"_170":-5,"_27":219},{"_43":204,"_32":205,"_30":206,"_165":-5,"_41":42,"_40":207,"_167":61,"_38":208,"_13":209,"_33":34,"_35":210,"_24":25,"_170":-5,"_27":211},{"_43":196,"_32":197,"_30":59,"_165":-5,"_41":42,"_40":198,"_167":25,"_38":199,"_13":200,"_33":201,"_35":202,"_24":25,"_170":45,"_27":203},{"_43":188,"_32":189,"_30":190,"_165":-5,"_41":42,"_40":191,"_167":61,"_38":192,"_13":193,"_33":34,"_35":194,"_24":25,"_170":-5,"_27":195},{"_43":180,"_32":181,"_30":182,"_165":-5,"_41":42,"_40":183,"_167":61,"_38":184,"_13":185,"_33":34,"_35":186,"_24":25,"_170":-5,"_27":187},{"_43":172,"_32":173,"_30":174,"_165":-5,"_41":42,"_40":175,"_167":25,"_38":176,"_13":177,"_33":34,"_35":178,"_24":25,"_170":-5,"_27":179},{"_43":162,"_32":163,"_30":164,"_165":-5,"_41":42,"_40":166,"_167":61,"_38":168,"_13":65,"_33":34,"_35":169,"_24":25,"_170":-5,"_27":171},"8b664cdb-aa06-4f54-a1b8-2b0844cc483e","typesafe.ts","01a0abce-8571-76e1-8061-e98d955a6ea6","parentId",1,"latest",["D",1789588833583],"/**\n * Minimal TypeSafe (System One) client.\n * Docs: https://docs.typesafe.ai/api\n *\n * One POST, one state, N typed questions, N typed answers.\n */\n\nconst ENDPOINT = \"https://api.typesafe.ai/v1/systemone\";\n\n/** Override with the TYPESAFE_MODEL env var to swap models without a deploy. */\nexport const MODEL = Deno.env.get(\"TYPESAFE_MODEL\") ?? \"jev-latest\";\n\nexport type NoulQuestion = {\n type: \"noul\";\n instructions: string;\n criteria?: { true?: string; false?: string };\n};\n\nexport type ChoiceQuestion = {\n type: \"choice\";\n instructions: string;\n criteria: Record;\n};\n\nexport type ScoreQuestion = {\n type: \"score\";\n instructions: string;\n criteria: string[];\n};\n\nexport type Question = NoulQuestion | ChoiceQuestion | ScoreQuestion;\n\nexport type NoulAnswer = { type: \"noul\"; noul: number };\n\nexport type ChoiceAnswer = {\n type: \"choice\";\n choice: string;\n probabilities: Record;\n confidence: number;\n};\n\nexport type ScoreAnswer = {\n type: \"score\";\n score: number;\n legend: Record;\n probabilities: Record;\n confidence: number;\n};\n\nexport type Answer = NoulAnswer | ChoiceAnswer | ScoreAnswer;\n\nexport type SystemOneResponse = {\n model: string;\n answers: Record;\n usage: { input_tokens: number; output_tokens: number };\n};\n\n/** The env var this client needs. Exported so the UI can name it. */\nexport const API_KEY_VAR = \"TYPESAFE_API_KEY\";\n\n/** Where to get one. */\nexport const API_KEY_CONSOLE_URL = \"https://console.typesafe.ai/settings/keys\";\n\n/**\n * Whether this val has a key to call TypeSafe with. Trims rather than merely\n * testing presence: a var that exists holding an empty string is the normal\n * state of a fresh remix, and is just as unusable as a missing one.\n */\nexport function isConfigured(): boolean {\n return !!Deno.env.get(API_KEY_VAR)?.trim();\n}\n\n/** Ask a batch of typed questions about a single piece of state. */\nexport async function ask(\n state: unknown,\n questions: Record,\n { timeoutMs = 10_000 }: { timeoutMs?: number } = {},\n): Promise {\n const apiKey = Deno.env.get(API_KEY_VAR)?.trim();\n if (!apiKey) throw new Error(`${API_KEY_VAR} is not set on this val`);\n\n const res = await fetch(ENDPOINT, {\n method: \"POST\",\n headers: {\n Authorization: `Bearer ${apiKey}`,\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify({ state, model: MODEL, questions }),\n signal: AbortSignal.timeout(timeoutMs),\n });\n\n if (!res.ok) {\n const body = await res.text();\n throw new Error(`TypeSafe ${res.status}: ${body.slice(0, 300)}`);\n }\n\n return await res.json() as SystemOneResponse;\n}","label",[163],"e3ad1e67-2697-4bd6-bae9-b6db7dcfddd9","sessions.ts","979add00-b209-11f1-8f64-1607ee4eb77e",102,["D",1789603885050],6,"/**\n * The registry of live browsers.\n *\n * A Kernel browser keeps running after the HTTP request that created it\n * returns, so \"which browsers exist\" can't live in the request that made one.\n * One row per session in SQLite, and the row is what `liveSessionCount()` —\n * and so the concurrency cap — counts. It's also what lets a later request\n * find a browser whose client walked away and delete it.\n *\n * Two limits live here, both about the browser rather than about requests:\n *\n * - `MAX_LIVE_SESSIONS` caps how many browsers run at once, matching\n * Kernel's Developer-tier ceiling of 5 concurrent browsers.\n * - `MAX_SESSION_SECONDS` caps one browser's life. Steps are what keep a\n * browser alive, so without a wall-clock cap a client that loops on\n * `/api/step` can hold one open indefinitely — `MAX_STEPS` bounds the work\n * a run does, not the time it takes.\n */\nimport { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\n\n/**\n * Read a positive integer from the environment, or fall back.\n *\n * The fallback on a *bad* value matters more than the fallback on a missing\n * one: `Number(\"5 \")` is 5 but `Number(\"five\")` is NaN, and every comparison\n * against NaN is false — so a typo'd override would turn a cap into no cap at\n * all. Failing closed keeps the ceiling a ceiling.\n */\nfunction envCount(name: string, fallback: number): number {\n const raw = Deno.env.get(name)?.trim();\n if (!raw) return fallback;\n const n = Number(raw);\n return Number.isFinite(n) && n >= 1 ? Math.floor(n) : fallback;\n}\n\n/**\n * How many browsers this demo will run at once.\n *\n * Kernel's Developer tier allows 5 concurrent browsers, so 5 is the real\n * ceiling: above it the sixth `createBrowser` is refused by Kernel and the\n * caller sees Kernel's error rather than this guard's. Raise this only\n * alongside a Kernel plan that allows more.\n *\n * Override with MAX_LIVE_SESSIONS.\n */\nexport const MAX_LIVE_SESSIONS = envCount(\"MAX_LIVE_SESSIONS\", 5);\n\n/**\n * How long one browser may live. 180s is well past a full 12-step run (about a\n * minute), so it never binds a real run — it only stops a browser from\n * outliving the run that made it.\n */\nexport const MAX_SESSION_SECONDS = 180;\n\nexport type SessionStatus = \"live\" | \"done\" | \"stopped\" | \"failed\";\n\nexport type Session = {\n id: string;\n kernelId: string;\n task: string;\n startUrl: string;\n startedAt: string;\n steps: number;\n status: SessionStatus;\n};\n\n/**\n * An earlier version of this table also carried `ip` and `charged_seconds`,\n * for a spend ledger that no longer exists. `CREATE TABLE IF NOT EXISTS`\n * leaves those columns in place on a database that already has them, and the\n * defaults on them keep inserts working — nothing reads or writes them now.\n */\nconst SCHEMA = `CREATE TABLE IF NOT EXISTS sessions (\n id TEXT PRIMARY KEY,\n kernel_id TEXT NOT NULL,\n task TEXT NOT NULL,\n start_url TEXT NOT NULL DEFAULT '',\n started_at TEXT NOT NULL,\n steps INTEGER NOT NULL DEFAULT 0,\n status TEXT NOT NULL DEFAULT 'live'\n)`;\n\nlet schema: Promise | null = null;\n\nfunction init(): Promise {\n if (!schema) {\n schema = sqlite.execute(SCHEMA).catch((err) => {\n schema = null; // let the next request try again\n throw err;\n });\n }\n return schema;\n}\n\nfunction toSession(row: Record): Session {\n return {\n id: String(row.id),\n kernelId: String(row.kernel_id),\n task: String(row.task),\n startUrl: String(row.start_url ?? \"\"),\n startedAt: String(row.started_at),\n steps: Number(row.steps ?? 0),\n status: String(row.status) as SessionStatus,\n };\n}\n\nexport async function createSession(\n kernelId: string,\n task: string,\n startUrl: string,\n): Promise {\n await init();\n const session: Session = {\n id: crypto.randomUUID(),\n kernelId,\n task,\n startUrl,\n startedAt: new Date().toISOString(),\n steps: 0,\n status: \"live\",\n };\n await sqlite.execute({\n sql: `INSERT INTO sessions\n (id, kernel_id, task, start_url, started_at, steps, status)\n VALUES (?, ?, ?, ?, ?, 0, 'live')`,\n args: [\n session.id,\n session.kernelId,\n session.task,\n session.startUrl,\n session.startedAt,\n ],\n });\n return session;\n}\n\nexport async function getSession(id: string): Promise {\n await init();\n const { rows } = await sqlite.execute({\n sql: \"SELECT * FROM sessions WHERE id = ?\",\n args: [id],\n });\n return rows[0] ? toSession(rows[0] as Record) : null;\n}\n\n/** Live browsers, for the concurrency guard. */\nexport async function liveSessionCount(): Promise {\n await init();\n const { rows } = await sqlite.execute(\n \"SELECT COUNT(*) AS n FROM sessions WHERE status = 'live'\",\n );\n return Number(rows[0]?.n ?? 0);\n}\n\nexport async function bumpSteps(id: string): Promise {\n await sqlite.execute({\n sql: \"UPDATE sessions SET steps = steps + 1 WHERE id = ?\",\n args: [id],\n });\n}\n\nexport async function closeSession(\n id: string,\n status: SessionStatus,\n): Promise {\n await sqlite.execute({\n sql: \"UPDATE sessions SET status = ? WHERE id = ?\",\n args: [status, id],\n });\n}\n\n/**\n * Close browsers whose clients walked away, and return their Kernel ids so the\n * caller can delete them.\n *\n * `/api/step` is what keeps a run moving, so a session nobody steps is a\n * browser nobody is driving: it sits there until Kernel's idle timeout deletes\n * it. Marking the row closed here is what stops the concurrency cap from\n * filling up with browsers that no longer have a client. There's no cron, so\n * the sweep is opportunistic — the next visitor's session creation runs it\n * before counting what's live.\n */\nexport async function sweepStaleSessions(\n maxAgeSeconds = MAX_SESSION_SECONDS,\n): Promise {\n await init();\n const cutoff = new Date(Date.now() - maxAgeSeconds * 1000).toISOString();\n const { rows } = await sqlite.execute({\n sql: \"SELECT * FROM sessions WHERE status = 'live' AND started_at < ?\",\n args: [cutoff],\n });\n\n const kernelIds: string[] = [];\n for (const row of rows) {\n const session = toSession(row as Record);\n await closeSession(session.id, \"stopped\");\n kernelIds.push(session.kernelId);\n }\n return kernelIds;\n}\n\n// Small per-run history, independent of client-provided action descriptions.\nconst HISTORY_SCHEMA = `CREATE TABLE IF NOT EXISTS run_history (\n session_id TEXT PRIMARY KEY,\n steps_json TEXT NOT NULL DEFAULT '[]'\n)`;\nlet historySchema: Promise | null = null;\n\nfunction initHistory(): Promise {\n return historySchema ??= sqlite.execute(HISTORY_SCHEMA).catch((err) => {\n historySchema = null;\n throw err;\n });\n}\n\nexport async function getHistory(sessionId: string): Promise {\n await initHistory();\n const { rows } = await sqlite.execute({\n sql: \"SELECT steps_json FROM run_history WHERE session_id = ?\",\n args: [sessionId],\n });\n return rows[0] ? JSON.parse(String(rows[0].steps_json)) : [];\n}\n\nexport async function saveHistory(\n sessionId: string,\n steps: import(\"./history.ts\").HistoryStep[],\n): Promise {\n await initHistory();\n await sqlite.execute({\n sql: \"INSERT INTO run_history (session_id, steps_json) VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET steps_json = excluded.steps_json\",\n args: [sessionId, JSON.stringify(steps)],\n });\n}\n",[173],"0e7e9088-7032-4643-b914-5505c1d7cc86","rate-limit.ts","01a0abce-8571-76e1-8061-e5086f72225b",81,["D",1789599861763],2,"/**\n * Best-effort in-memory rate limit, so a public demo can't be hammered.\n * Each isolate keeps its own window, so the effective limit is a bit looser\n * than the numbers below. Good enough for a demo; swap for sqlite if it matters.\n *\n * Counters are per *bucket* rather than shared across the module, because the\n * two things being limited here differ by orders of magnitude in weight:\n * starting a browser is a long-lived, heavyweight thing, and a step is a cheap\n * request that keeps one alive. Sharing one counter would let a burst of steps\n * exhaust the allowance for starting a browser.\n */\n\ntype Bucket = { perKey: Map; global: number[] };\n\nconst buckets = new Map();\n\nfunction bucketOf(name: string): Bucket {\n let bucket = buckets.get(name);\n if (!bucket) {\n bucket = { perKey: new Map(), global: [] };\n buckets.set(name, bucket);\n }\n return bucket;\n}\n\nexport type LimitResult =\n | { ok: true }\n | { ok: false; reason: \"per-key\" | \"global\"; retryAfterMs: number };\n\nexport function checkRateLimit(\n key: string,\n { perKey = 600, global = 6000, windowMs = 60_000, bucket = \"default\" } = {},\n): LimitResult {\n const now = Date.now();\n const cutoff = now - windowMs;\n const state = bucketOf(bucket);\n\n const keyHits = (state.perKey.get(key) ?? []).filter((t) => t > cutoff);\n state.global = state.global.filter((t) => t > cutoff);\n\n if (keyHits.length >= perKey) {\n return { ok: false, reason: \"per-key\", retryAfterMs: keyHits[0] + windowMs - now };\n }\n if (state.global.length >= global) {\n return { ok: false, reason: \"global\", retryAfterMs: state.global[0] + windowMs - now };\n }\n\n keyHits.push(now);\n state.global.push(now);\n state.perKey.set(key, keyHits);\n\n // Crude memory guard for a long-lived isolate.\n if (state.perKey.size > 5000) state.perKey.clear();\n\n return { ok: true };\n}",[181],"822835a2-76a4-44d9-90ac-b2bc74d310ce","kernel.ts","01a0abcf-a6b5-7413-8f55-6a07a5e01800",88,["D",1789599875697],5,"/**\n * Kernel client — the cloud Chromium the agent drives.\n *\n * Adapted from @stevekrouse/browser-tester's `lib/browser.ts`, which is the\n * same API base, Bearer auth, error handling, and replay helpers. What's added\n * here is what browser *use* needs rather than browser *testing*:\n *\n * - `createBrowser` asks for kiosk mode and a fixed viewport, and returns the\n * live view URL the demo embeds in an iframe.\n * - The computer controls (real OS mouse and keyboard) that the agent acts\n * with, so the cursor moves along a Bézier path and typing is human-paced.\n *\n * Docs: https://www.kernel.sh/docs\n */\nconst API = \"https://api.onkernel.com\";\n\n/**\n * Read the key lazily, not at module load. A missing key should be a 503 the\n * page can explain, not an import-time throw that takes the whole val down.\n */\nfunction key(): string {\n const k = Deno.env.get(API_KEY_VAR)?.trim();\n if (!k) throw new Error(`${API_KEY_VAR} is not set on this val`);\n return k;\n}\n\n/** The env var this client needs. Exported so the UI can name it. */\nexport const API_KEY_VAR = \"KERNEL_API_KEY\";\n\n/** Where to get one. */\nexport const API_KEY_CONSOLE_URL = \"https://dashboard.onkernel.com/settings/api-keys\";\n\nexport function isConfigured(): boolean {\n return !!Deno.env.get(API_KEY_VAR)?.trim();\n}\n\nexport type KernelResponse = {\n status: number;\n headers: Headers;\n text: () => Promise;\n arrayBuffer: () => Promise;\n};\n\nexport async function kernelFetch(\n path: string,\n method = \"GET\",\n body?: unknown,\n): Promise {\n const res = await fetch(API + path, {\n method,\n headers: {\n Authorization: `Bearer ${key()}`,\n ...(body ? { \"Content-Type\": \"application/json\" } : {}),\n },\n body: body ? JSON.stringify(body) : undefined,\n });\n return {\n status: res.status,\n headers: res.headers,\n text: () => res.text(),\n arrayBuffer: () => res.arrayBuffer(),\n };\n}\n\n/** POST that expects a JSON body back, with the status in the error. */\nasync function postJson(path: string, body?: unknown): Promise {\n const r = await kernelFetch(path, \"POST\", body);\n const text = await r.text();\n if (r.status >= 300) {\n // 401/403 is the one failure worth naming precisely. It's also the one that\n // reads as a mystery: `/api/config` reports the key as *present*, so the\n // page looks configured while every call is refused. Say what to check.\n if (r.status === 401 || r.status === 403) {\n throw new Error(\n `Kernel rejected ${API_KEY_VAR} (${r.status}: ${text.slice(0, 120)}). ` +\n `Check the value is complete and from ${API_KEY_CONSOLE_URL}`,\n );\n }\n throw new Error(`Kernel ${path} failed (${r.status}): ${text.slice(0, 300)}`);\n }\n return text ? JSON.parse(text) as T : ({} as T);\n}\n\nexport type KernelBrowser = {\n session_id: string;\n browser_live_view_url: string;\n cdp_ws_url?: string;\n};\n\n/**\n * Create a browser session.\n *\n * Kiosk mode is not cosmetic. It removes the tab strip and toolbar, so the\n * window *is* the page viewport and `getBoundingClientRect()` coordinates are\n * already screen coordinates — which is what the computer controls click. With\n * browser chrome in the way every click would land a toolbar-height too high.\n * It also makes the live view a clean full-bleed rectangle for the video.\n *\n * `timeout_seconds` is Kernel's idle auto-delete ceiling, and it's the thing\n * that stops an abandoned browser from living forever.\n */\n/**\n * The viewport the demo's browsers run at. In kiosk mode the window *is* the\n * page viewport, so this is also the screen the computer controls address —\n * and the bound their coordinates have to stay inside. Kernel rejects\n * out-of-bounds coordinates with a 400 rather than clamping them.\n */\nexport const VIEWPORT = { width: 1024, height: 768 };\n\nexport async function createBrowser(\n opts: {\n name?: string;\n startUrl?: string;\n width?: number;\n height?: number;\n idleTimeoutSec?: number;\n } = {},\n): Promise {\n const {\n name,\n startUrl,\n width = VIEWPORT.width,\n height = VIEWPORT.height,\n idleTimeoutSec = 240,\n } = opts;\n return await postJson(\"/browsers\", {\n headless: false,\n kiosk_mode: true,\n viewport: { width, height },\n timeout_seconds: idleTimeoutSec,\n ...(name ? { name } : {}),\n // Boot straight at the start URL rather than the new-tab home page.\n ...(startUrl ? { start_url: startUrl } : {}),\n });\n}\n\n/** Execute Playwright/TypeScript against the browser, with page/context/browser in scope. */\nexport async function runPlaywright(\n sessionId: string,\n code: string,\n timeoutSec = 45,\n): Promise<{ success: boolean; result?: unknown; error?: string; stdout?: string }> {\n return await postJson(`/browsers/${sessionId}/playwright/execute`, {\n code,\n timeout_sec: timeoutSec,\n });\n}\n\n// ── Computer controls ───────────────────────────────────────────\n// A real OS mouse and keyboard, not synthetic DOM events. `smooth` is Kernel's\n// default and draws a human-like Bézier path, which is most of why the demo is\n// watchable rather than a series of jumps.\n\n/** Move the cursor. Smooth by default, so the path is visible in the live view. */\nexport async function moveMouse(\n sessionId: string,\n x: number,\n y: number,\n durationMs?: number,\n): Promise {\n await postJson(`/browsers/${sessionId}/computer/move_mouse`, {\n x,\n y,\n smooth: true,\n ...(durationMs ? { duration_ms: durationMs } : {}),\n });\n}\n\nexport async function clickMouse(\n sessionId: string,\n x: number,\n y: number,\n): Promise {\n await postJson(`/browsers/${sessionId}/computer/click_mouse`, { x, y });\n}\n\n/** Type literal text, human-paced. */\nexport async function typeText(sessionId: string, text: string): Promise {\n await postJson(`/browsers/${sessionId}/computer/type_text`, { text });\n}\n\nexport async function pressKey(sessionId: string, keys: string[]): Promise {\n await postJson(`/browsers/${sessionId}/computer/press_key`, { keys });\n}\n\n/** Capture a screenshot; returns raw PNG bytes. */\nexport async function screenshot(sessionId: string): Promise {\n const r = await kernelFetch(`/browsers/${sessionId}/computer/screenshot`, \"POST\", {});\n if (r.status !== 200) {\n throw new Error(`screenshot failed (${r.status}): ${await r.text()}`);\n }\n return r.arrayBuffer();\n}\n\n/** Delete a browser session. Frees the concurrency slot. */\nexport async function destroyBrowser(sessionId: string): Promise {\n const r = await kernelFetch(`/browsers/${sessionId}`, \"DELETE\");\n if (r.status !== 204 && r.status !== 200) {\n throw new Error(`destroyBrowser failed (${r.status}): ${await r.text()}`);\n }\n}\n\nexport function sleep(ms: number): Promise {\n return new Promise((resolve) => setTimeout(resolve, ms));\n}",[189],"555d0fd1-eaf5-496d-a5ff-cb4692139a25","index.ts",150,["D",1789604447305],22,"http","import {\n hotReload,\n parseVal,\n serveImmutableFile,\n} from \"https://esm.town/v/std/utils/index.ts\";\nimport { Hono } from \"npm:hono\";\nimport { act, describeAction, perceive } from \"./browser-use.ts\";\nimport { decide } from \"./decide.ts\";\nimport { observePrevious, pageKey, repeatedAction, rememberAttempt } from \"./history.ts\";\nimport { Root } from \"./frontend/root.tsx\";\nimport {\n API_KEY_CONSOLE_URL as KERNEL_CONSOLE_URL,\n API_KEY_VAR as KERNEL_VAR,\n createBrowser,\n destroyBrowser,\n isConfigured as kernelConfigured,\n} from \"./kernel.ts\";\nimport { checkRateLimit } from \"./rate-limit.ts\";\nimport {\n bumpSteps,\n closeSession,\n createSession,\n getSession,\n getHistory,\n saveHistory,\n liveSessionCount,\n MAX_LIVE_SESSIONS,\n MAX_SESSION_SECONDS,\n type Session,\n type SessionStatus,\n sweepStaleSessions,\n} from \"./sessions.ts\";\nimport {\n API_KEY_CONSOLE_URL as TYPESAFE_CONSOLE_URL,\n API_KEY_VAR as TYPESAFE_VAR,\n isConfigured as typesafeConfigured,\n} from \"./typesafe.ts\";\n\n/** How many steps one run may take. Each step is two Jev calls and ~4s of browser. */\nconst MAX_STEPS = 12;\n\n/** Task and URL caps, so a pasted novel can't blow up one Jev request. */\nconst MAX_TASK_CHARS = 500;\n\n/** Where a run starts when you don't say. The blog's own wikiracing example. */\nconst DEFAULT_START_URL = \"https://en.wikipedia.org/wiki/Rubber_duck\";\n\n/** One-click demos. Wikiracing is TypeSafe's own showcase task for Jev. */\nconst PRESETS = [\n {\n label: \"Wikiracing\",\n task: \"Reach the article about the Eiffel Tower, using only links on the page.\",\n startUrl: \"https://en.wikipedia.org/wiki/Rubber_duck\",\n },\n {\n label: \"Hacker News\",\n task: \"Open the comments for the top story on the front page.\",\n startUrl: \"https://news.ycombinator.com\",\n },\n {\n label: \"Val Town\",\n task: \"Find the pricing page and tell me what the cheapest paid plan costs.\",\n startUrl: \"https://www.val.town\",\n },\n];\n\nconst app = new Hono();\n\n/**\n * What the browser needs in order to explain a val that's missing a key:\n * whether the gap exists, and where to fill it. The env var editor URL is\n * derived from the val itself, so a fork sends people to its own settings.\n *\n * Nothing secret goes over the wire — only whether the gap exists.\n */\nfunction setupState() {\n const val = parseVal().links.self.val;\n const one = (keyVar: string, consoleUrl: string, configured: boolean) => ({\n configured,\n keyVar,\n envUrl: `${val}/environment-variables?key=${keyVar}`,\n consoleUrl,\n });\n return {\n typesafe: one(TYPESAFE_VAR, TYPESAFE_CONSOLE_URL, typesafeConfigured()),\n kernel: one(KERNEL_VAR, KERNEL_CONSOLE_URL, kernelConfigured()),\n };\n}\n\nfunction ipOf(c: { req: { header: (k: string) => string | undefined } }): string {\n return c.req.header(\"x-forwarded-for\")?.split(\",\")[0]?.trim() ||\n c.req.header(\"x-real-ip\") || \"unknown\";\n}\n\n/** Accept a bare host too, so \"val.town\" works. Empty falls back to the default. */\nfunction normalizeUrl(raw: unknown): string {\n const s = typeof raw === \"string\" ? raw.trim() : \"\";\n if (!s) return DEFAULT_START_URL;\n const withScheme = /^https?:\\/\\//i.test(s) ? s : `https://${s}`;\n try {\n return new URL(withScheme).toString();\n } catch {\n return DEFAULT_START_URL;\n }\n}\n\n/** End a run: mark the session closed, then delete the browser at Kernel. */\nasync function finish(session: Session, status: SessionStatus): Promise {\n if (session.status !== \"live\") return;\n await closeSession(session.id, status);\n await destroyBrowser(session.kernelId).catch((err) =>\n console.error(\"destroyBrowser failed:\", err)\n );\n}\n\n// ── Shell ───────────────────────────────────────────────────────\n// Never cached, so it can stamp the current version into each asset URL.\napp.get(\"/\", (c) => c.html(Root()));\n\n// The version-addressed asset URLs Root() stamps, cached immutably.\napp.get(\"/__immutable/*\", (c) => serveImmutableFile(c.req.path));\n\napp.get(\"/source\", (c) => c.redirect(parseVal().links.self.val));\n\n// ── API ─────────────────────────────────────────────────────────\napp.get(\"/api/config\", (c) =>\n c.json({\n setup: setupState(),\n presets: PRESETS,\n maxSteps: MAX_STEPS,\n maxLiveSessions: MAX_LIVE_SESSIONS,\n }));\n\n/** Start a run: one browser, one task. */\napp.post(\"/api/session\", async (c) => {\n if (!typesafeConfigured() || !kernelConfigured()) {\n return c.json({\n error: \"this val is missing an API key\",\n reason: \"unconfigured\",\n setup: setupState(),\n }, 503);\n }\n\n const body = await c.req.json().catch(() => null);\n const task = typeof body?.task === \"string\"\n ? body.task.trim().slice(0, MAX_TASK_CHARS)\n : \"\";\n if (!task) return c.json({ error: \"describe a task first\" }, 400);\n const startUrl = normalizeUrl(body?.startUrl);\n\n const ip = ipOf(c);\n\n // A browser is a long-lived, heavyweight thing, so this limit is much tighter\n // than a per-keystroke demo's would be.\n const limit = checkRateLimit(ip, {\n perKey: 6,\n global: 60,\n windowMs: 60_000,\n bucket: \"session\",\n });\n if (!limit.ok) {\n return c.json({\n error: \"rate limited\",\n reason: limit.reason,\n retryAfterMs: limit.retryAfterMs,\n }, 429);\n }\n\n // Close out any browser whose client walked away, before working out whether\n // there's room for another. There's no cron here, so session creation is\n // where the registry gets reconciled — otherwise a browser nobody is driving\n // holds a concurrency slot forever.\n for (const kernelId of await sweepStaleSessions()) {\n await destroyBrowser(kernelId).catch((err) =>\n console.error(\"sweep destroyBrowser failed:\", err)\n );\n }\n\n if (await liveSessionCount() >= MAX_LIVE_SESSIONS) {\n return c.json({\n error: `${MAX_LIVE_SESSIONS} browsers are already running — stop one first`,\n reason: \"concurrency\",\n }, 429);\n }\n\n // Creating the browser is the step most likely to fail for a reason the\n // caller can act on (a rejected key, a concurrency limit), so it gets its own\n // catch. Without one the throw escapes to Val Town's error envelope, which\n // has no `error` field for the client to read.\n let browser;\n try {\n browser = await createBrowser({\n name: `jev-${Date.now()}`,\n startUrl,\n });\n } catch (err) {\n console.error(\"createBrowser failed:\", err);\n // 500, not 502. The CDN replaces an origin 502 with its own HTML error\n // page, so the val's JSON body never arrives and the client dies parsing\n // a DOCTYPE. 500 passes through intact.\n return c.json({\n error: err instanceof Error ? err.message : String(err),\n reason: \"kernel\",\n setup: setupState(),\n }, 500);\n }\n\n const session = await createSession(browser.session_id, task, startUrl);\n\n return c.json({\n sessionId: session.id,\n task,\n startUrl,\n // readOnly so a viewer can't fight the agent for the mouse, and so the\n // demo is a demo rather than a shared remote desktop.\n liveViewUrl: `${browser.browser_live_view_url}?readOnly=true`,\n });\n});\n\n/**\n * One turn of the loop: read the page, ask Jev, act.\n *\n * The client drives this rather than the server looping, so each request stays\n * short and the UI can show every step as it lands.\n */\napp.post(\"/api/step\", async (c) => {\n // Steps are what keep a browser alive, so they're limited too. Without this,\n // looping on this endpoint is a way to hold a browser open without ever\n // starting a second one. Generous next to the session limit — a real run\n // does ~15-20 steps a minute — but it bounds a client that just hammers it.\n const limit = checkRateLimit(ipOf(c), {\n perKey: 90,\n global: 300,\n windowMs: 60_000,\n bucket: \"step\",\n });\n if (!limit.ok) {\n return c.json({\n error: \"rate limited\",\n reason: limit.reason,\n retryAfterMs: limit.retryAfterMs,\n }, 429);\n }\n\n const body = await c.req.json().catch(() => null);\n const session = await getSession(typeof body?.sessionId === \"string\" ? body.sessionId : \"\");\n if (!session) return c.json({ error: \"no such session\" }, 404);\n if (session.status !== \"live\") {\n return c.json({ error: `run is already ${session.status}`, status: session.status }, 409);\n }\n\n // A browser bills whether or not anyone is watching it, so the run ends\n // rather than the browser outliving the run that made it.\n const ageSeconds = (Date.now() - new Date(session.startedAt).getTime()) / 1000;\n if (ageSeconds >= MAX_SESSION_SECONDS) {\n await finish(session, \"done\");\n return c.json({\n step: session.steps,\n done: true,\n reason: \"time limit\",\n action: `stopped after ${MAX_SESSION_SECONDS}s of browser`,\n });\n }\n\n if (session.steps >= MAX_STEPS) {\n await finish(session, \"done\");\n return c.json({\n step: session.steps,\n done: true,\n reason: \"step limit\",\n action: `stopped after ${MAX_STEPS} steps`,\n });\n }\n\n try {\n const page = await perceive(session.kernelId);\n const state = await pageKey(page);\n const history = await getHistory(session.id);\n observePrevious(history, page, state);\n await saveHistory(session.id, history);\n const memory = { state, steps: history };\n const decision = await decide(page, session.task, [], memory);\n if ((decision.target || decision.action === \"back\") && repeatedAction(decision, page, memory)) {\n decision.action = \"stuck\";\n decision.target = undefined;\n decision.text = undefined;\n decision.back = undefined;\n }\n\n // A failed click is not a failed run. Kernel rejects out-of-bounds\n // coordinates outright, and the next step simply perceives again and picks\n // something else — so record it and keep the browser, rather than tearing\n // down one we're still paying for and ending the run on step one.\n let actionError: string | null = null;\n if (decision.action === \"back\" || (decision.target && decision.action !== \"done\" && decision.action !== \"stuck\")) {\n const record = rememberAttempt(page, state, decision, describeAction(decision));\n // Persist before acting: a lost response must not erase an attempted action.\n history.push(record);\n await saveHistory(session.id, history);\n try {\n await act(session.kernelId, decision);\n } catch (err) {\n actionError = err instanceof Error ? err.message : String(err);\n record.outcome = \"error\";\n record.error = actionError;\n await saveHistory(session.id, history);\n console.error(\"act failed (continuing):\", actionError);\n }\n }\n await bumpSteps(session.id);\n\n const done = decision.action === \"done\" || decision.action === \"stuck\";\n if (done) await finish(session, decision.action === \"stuck\" ? \"stopped\" : \"done\");\n\n return c.json({\n step: session.steps + 1,\n done,\n action: actionError ? `${describeAction(decision)} — failed: ${actionError}` : describeAction(decision),\n reason: decision.action === \"stuck\" ? \"stuck\" : undefined,\n page: {\n url: page.url,\n title: page.title,\n candidates: page.candidates.length,\n },\n decision,\n });\n } catch (err) {\n await finish(session, \"failed\");\n console.error(\"step failed:\", err);\n return c.json({\n error: err instanceof Error ? err.message : String(err),\n reason: \"upstream\",\n }, 500);\n }\n});\n\n/** Stop a run and delete its browser. */\napp.post(\"/api/session/:id/stop\", async (c) => {\n const session = await getSession(c.req.param(\"id\"));\n if (!session) return c.json({ error: \"no such session\" }, 404);\n await finish(session, \"stopped\");\n return c.json({ ok: true });\n});\n\n// Unwrap and rethrow Hono errors as the original error.\napp.onError((err) => Promise.reject(err));\n\nexport default hotReload(app.fetch);",[197],"99f68993-3d2f-4621-aeb7-a1be9639aaa0","history.ts","51a75922-b22c-11f1-973e-1607ee4eb77e",132,["D",1789604411595],3,"import type { Candidate, Decision, PageState } from \"./decide.ts\";\n\nexport type HistoryStep = {\n state: string;\n url: string;\n target: string;\n action: string;\n description: string;\n afterUrl?: string;\n /** Optional for compatibility with sessions started before Back was added. */\n entryId?: number;\n controls?: { key: string; label: string }[];\n outcome: \"pending\" | \"changed\" | \"unchanged\" | \"error\";\n error?: string;\n};\n\nexport type RunMemory = { state: string; steps: HistoryStep[] };\n\nexport type BackOption = {\n fromEntryId: number;\n entryId: number;\n url: string;\n alternatives: string[];\n};\n\n/** Only offer the actual previous browser entry, with known untried controls. */\nexport function backOption(page: PageState, memory?: RunMemory): BackOption | undefined {\n const nav = page.navigation;\n if (!memory || !nav?.previous) return;\n const prior = [...memory.steps].reverse().find((step) =>\n step.entryId === nav.previous!.id && step.url === nav.previous!.url && step.controls\n );\n if (!prior) return;\n const tried = new Set(memory.steps.filter((step) => step.state === prior.state).map((step) => step.target));\n const alternatives = prior.controls!.filter((c) => !tried.has(c.key)).map((c) => c.label);\n if (!alternatives.length) return;\n const option = {\n fromEntryId: nav.currentId, entryId: nav.previous.id,\n url: nav.previous.url, alternatives: alternatives.slice(0, 8),\n };\n const key = JSON.stringify([\"back\", option.url, \"\"]);\n if (memory.steps.some((step) => step.state === memory.state && step.action === key)) return;\n return option;\n}\n\n/** Snapshots let a later dead end discover alternatives on its parent page. */\nexport function rememberAttempt(page: PageState, state: string, decision: Decision, description: string): HistoryStep {\n return {\n state, url: page.url,\n target: decision.target ? targetKey(decision.target, page.url) : \"__back__\",\n action: actionKey(decision, page.url), description, outcome: \"pending\",\n entryId: page.navigation?.currentId,\n controls: page.candidates.filter((c) => !c.editable).map((c) => ({\n key: targetKey(c, page.url), label: c.label,\n })),\n };\n}\n\n/** Preserve query and fragment: both can identify meaningful application state. */\nexport function absoluteUrl(href: string, base: string): string {\n try { return new URL(href, base).href; } catch { return href; }\n}\n\n/** DOM indexes and screen positions are only valid for one observation. */\nexport function targetKey(candidate: Candidate, url: string): string {\n return candidate.tag === \"a\" && candidate.href\n ? JSON.stringify([\"link\", absoluteUrl(candidate.href, url)])\n : JSON.stringify([candidate.tag, candidate.label.trim(), !!candidate.editable]);\n}\n\nexport function actionKey(decision: Decision, url: string): string {\n return JSON.stringify([\n decision.action,\n decision.action === \"back\" ? decision.back?.url ?? \"\" : decision.target ? targetKey(decision.target, url) : \"\",\n decision.text ?? \"\",\n ]);\n}\n\n/** Sorting makes scrolling/reordering candidates irrelevant to state identity. */\nexport async function pageKey(page: PageState): Promise {\n const content = JSON.stringify([\n absoluteUrl(page.url, page.url),\n page.text.replace(/\\s+/g, \" \").trim(),\n [...new Set(page.candidates.map((c) => targetKey(c, page.url)))].sort(),\n ]);\n const digest = await crypto.subtle.digest(\"SHA-256\", new TextEncoder().encode(content));\n return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n}\n\nexport function availableCandidates(page: PageState, memory?: RunMemory): Candidate[] {\n if (!memory) return page.candidates;\n const tried = new Set(memory.steps\n .filter((step) => step.state === memory.state)\n .map((step) => step.target));\n // Editable fields may need a different string. The exact action is checked\n // again before execution so repeated submissions are still stopped.\n return page.candidates.filter((c) => c.editable || !tried.has(targetKey(c, page.url)));\n}\n\nexport function repeatedAction(decision: Decision, page: PageState, memory: RunMemory): boolean {\n const key = actionKey(decision, page.url);\n return memory.steps.some((step) => step.state === memory.state && step.action === key);\n}\n\nexport function observePrevious(steps: HistoryStep[], page: PageState, state: string): void {\n const previous = steps[steps.length - 1];\n if (!previous || previous.afterUrl !== undefined) return;\n previous.afterUrl = page.url;\n if (previous.outcome !== \"error\") {\n previous.outcome = previous.state === state ? \"unchanged\" : \"changed\";\n }\n}\n",[205],"55f140e9-8a56-441a-b6a0-b5dfa4389f4e","decide.ts","a8691e76-b209-11f1-b405-1607ee4eb77e",179,["D",1789605211052],40,"/**\n * The Jev half of the loop: given a text description of the page and a goal,\n * decide what to do next.\n *\n * Jev can't emit an action. It has no string output at all — only Choice,\n * Score, and Noul — so \"browser use\" here is not a model emitting tool calls.\n * It's the model *ranking and choosing* from a closed set that this file builds\n * out of the page, and then ordinary code doing the clicking. That constraint\n * is the whole design: every action is a value Jev was handed, so it cannot\n * invent a selector, hallucinate a URL, or make a type error.\n *\n * Two stages, which is what TypeSafe does for high-cardinality choices (their\n * wikiracing demo, \"Jev supports a cardinality up to 255... for the higher\n * cardinality choices, we do a 2 stage-system of scoring independently then\n * making an explicit choice\"):\n *\n * 1. Score — one Noul per candidate: \"does activating this move us closer?\"\n * Independent judgments, so they run in parallel and cost one call.\n * 2. Choose — one Choice over the top finalists, plus a way out (`__done__`).\n *\n * Stage 1 is a filter, not a decision. It never picks anything; it just makes\n * stage 2's choice set small enough to be a real choice.\n */\nimport { ask, type Answer, type Question } from \"./typesafe.ts\";\nimport { selectCandidates, type PageRegion } from \"./candidates.ts\";\nimport { availableCandidates, backOption, type BackOption, type RunMemory } from \"./history.ts\";\n\n/**\n * Candidates sent to stage 1. Beyond this we'd rather lose links than the call:\n * stage 1 asks two questions per candidate, and the documented request budget\n * is ~32k tokens.\n */\nconst MAX_CANDIDATES = 60;\n\n/** Finalists stage 2 chooses among. Small enough to be a comparison, not a scan. */\nconst FINALISTS = 24;\n\n/** Recent actions, so Jev can tell \"we're going in circles\" from \"we're progressing\". */\nconst HISTORY = 6;\n\nconst REGION_GUIDANCE =\n \"Judge relevance to the user's goal using the label, destination, and page context. Region describes placement, not relevance: navigation can lead to other sections; content controls can act within the current page. Do not favor or reject a control solely because of its region.\";\n\nexport type Candidate = {\n /** Stable within one page state; the key Jev's answers come back under. */\n n: number;\n /**\n * The element's `data-jev` attribute in the live DOM. This is what makes a\n * candidate addressable later: `act()` uses it to scroll the element into\n * view and re-read its position, rather than trusting coordinates measured a\n * Jev round trip ago (or clicking off-screen at a stale one).\n */\n dom: number;\n tag: string;\n label: string;\n href?: string;\n region?: PageRegion;\n /** Viewport coordinates of the element's centre, for the computer controls. */\n x: number;\n y: number;\n /** True when this is a text field, i.e. clicking it isn't enough. */\n editable?: boolean;\n};\n\nexport type PageState = {\n url: string;\n title: string;\n /** Visible text, flattened. Jev never sees a screenshot — only this. */\n text: string;\n candidates: Candidate[];\n navigation?: { currentId: number; previous?: { id: number; url: string } };\n};\n\n/**\n * One candidate's two independent judgments, plus the composite code makes of\n * them. `goal` and `closer` stay separate all the way to the UI: they answer\n * different questions, and the gap between them is what the score strip shows.\n */\nexport type Ranked = {\n candidate: Candidate;\n /** Noul: this control *is* what the goal names. */\n goal: number;\n /** Noul: this control is a useful next step, even if it isn't the goal. */\n closer: number;\n /** Probabilistic OR of the two: `goal + (1 - goal) * closer`. */\n score: number;\n};\n\nexport type Decision = {\n action: \"click\" | \"type\" | \"back\" | \"done\" | \"stuck\";\n back?: BackOption;\n target?: Candidate;\n text?: string;\n /** Jev's probability for the option it chose, and the answer's own confidence. */\n probability?: number;\n confidence?: number;\n /** Noul: how likely the page already satisfies the goal. */\n goalReached: number;\n /** Stage 1's output, best first. The UI shows the distribution. */\n ranked: Ranked[];\n /** How many candidates stage 1 saw. */\n considered: number;\n usage: { input_tokens: number; output_tokens: number };\n model: string;\n ms: number;\n};\n\n/**\n * Strings we could plausibly type, harvested from the task itself. Jev can't\n * write text, so anything typed has to come from the user's own words — quoted\n * phrases are the honest source, and a task with none simply can't type.\n */\nexport function harvestTexts(task: string): string[] {\n const out: string[] = [];\n const re = /\"([^\"\\n]{1,80})\"|'([^'\\n]{1,80})'|“([^”\\n]{1,80})”/g;\n for (const m of task.matchAll(re)) {\n const value = (m[1] ?? m[2] ?? m[3] ?? \"\").trim();\n if (value) out.push(value);\n }\n return [...new Set(out)];\n}\n\n/** Labels, destinations, and page regions give Jev task-independent context. */\nfunction describe(c: Candidate): string {\n const href = c.href ? ` → ${c.href}` : \"\";\n return `\"${c.label}\" (${c.tag}, region: ${c.region ?? \"content\"}${href})`;\n}\n\nfunction noulOf(answer: Answer | undefined): number {\n return answer?.type === \"noul\" ? answer.noul : 0;\n}\n\nexport async function decide(\n page: PageState,\n task: string,\n history: string[],\n memory?: RunMemory,\n askModel: typeof ask = ask,\n): Promise {\n const started = performance.now();\n // Filter before the cap, allowing previously hidden alternatives to enter.\n const considered = selectCandidates(availableCandidates(page, memory), MAX_CANDIDATES);\n const recent = memory\n ? memory.steps.slice(-HISTORY).map(({ url, description, afterUrl, outcome, error }) => ({\n from: url, action: description, to: afterUrl, outcome, error,\n }))\n : history.slice(-HISTORY);\n\n // ── Stage 1: score every candidate independently ────────────────\n // Two questions per candidate, not one. A single \"does this move us closer?\"\n // conflates the goal itself with a step toward it, and measurably does: on a\n // fixture where the goal link sat beside \"Gustave Eiffel\", the one-question\n // version ranked the biographer above the tower and clicked him. Asking the\n // two things separately and combining them in code fixes that, and costs one\n // call either way — questions in a request are evaluated in parallel.\n const scoreQuestions: Record = {};\n for (const c of considered) {\n scoreQuestions[`g${c.n}`] = {\n type: \"noul\",\n instructions:\n `This control IS the goal — activating it lands on exactly the page or thing the goal names. The control is ${describe(c)}. ${REGION_GUIDANCE}`,\n };\n scoreQuestions[`c${c.n}`] = {\n type: \"noul\",\n instructions:\n `This control is a useful next step toward the goal, even though it is not the goal itself. The control is ${describe(c)}. ${REGION_GUIDANCE}`,\n };\n }\n\n const scoreState = {\n goal: task,\n current_page: { url: page.url, title: page.title },\n page_text: page.text,\n recent_actions: recent,\n };\n\n const stage1 = considered.length\n ? await askModel(scoreState, scoreQuestions)\n : { answers: {} as Record, usage: { input_tokens: 0, output_tokens: 0 } };\n\n // Combining the two answers is code's job, not the model's. A probabilistic\n // OR is the right shape: a candidate is promising if it either *is* the goal\n // or clearly leads toward it. When the goal link isn't on the page at all,\n // the second term is the only one that fires — which is the multi-hop case.\n const ranked: Ranked[] = considered\n .map((candidate) => {\n const goal = noulOf(stage1.answers[`g${candidate.n}`]);\n const closer = noulOf(stage1.answers[`c${candidate.n}`]);\n return { candidate, goal, closer, score: goal + (1 - goal) * closer };\n })\n .sort((a, b) => b.score - a.score);\n\n const finalists = ranked.slice(0, FINALISTS);\n const recovery = backOption(page, memory);\n\n // ── Stage 2: choose among the finalists ─────────────────────────\n const criteria: Record = {\n __done__: \"The goal is already achieved on this page — stop and report success.\",\n __stuck__: \"No remaining control makes useful progress — stop without claiming success.\",\n };\n if (recovery) {\n criteria.__back__ = `Go back one browser history entry to ${recovery.url} and try an unexplored route. Remaining controls include: ${recovery.alternatives.join(\", \")}. Use this when the current controls do not offer useful progress. This is navigation, not undo.`;\n }\n for (const f of finalists) criteria[`c${f.candidate.n}`] = describe(f.candidate);\n\n const texts = harvestTexts(task);\n const questions: Record = {\n goal_reached: {\n type: \"noul\",\n instructions:\n \"The page currently displayed already satisfies the goal, with nothing further to do.\",\n },\n next: {\n type: \"choice\",\n instructions:\n \"Which single control should be activated next to make progress toward the goal? Consider the recorded outcomes and avoid routes that led back to visited pages. If current controls do not offer useful progress, choose __back__ when offered to explore another route. Choose __stuck__ only if neither a control nor recovery is useful; __done__ only if the goal is achieved. \" + REGION_GUIDANCE,\n criteria,\n },\n };\n\n // Only asked when it can matter, and only when there is something to type.\n if (texts.length) {\n questions.needs_text = {\n type: \"noul\",\n instructions:\n \"The control chosen above needs text typed into it before it does anything useful.\",\n };\n questions.text = {\n type: \"choice\",\n instructions:\n \"Which of these strings should be typed into the chosen control?\",\n criteria: Object.fromEntries([\n ...texts.map((t) => [t, t] as const),\n [\"__none__\", \"None of these — type nothing.\"] as const,\n ]),\n };\n }\n\n const stage2 = await askModel(\n {\n goal: task,\n current_page: { url: page.url, title: page.title },\n page_text: page.text,\n recent_actions: recent,\n finalists: finalists.map((f) => ({\n control: describe(f.candidate),\n is_the_goal: Number(f.goal.toFixed(2)),\n moves_closer: Number(f.closer.toFixed(2)),\n promising: Number(f.score.toFixed(2)),\n })),\n },\n questions,\n );\n\n const answers = stage2.answers;\n const goalReached = noulOf(answers.goal_reached);\n const pick = answers.next?.type === \"choice\" ? answers.next : undefined;\n const chosenKey = pick?.choice ?? \"__stuck__\";\n const chosen = finalists.find((f) => `c${f.candidate.n}` === chosenKey)?.candidate;\n\n const needsText = noulOf(answers.needs_text) >= 0.5;\n const textPick = answers.text?.type === \"choice\" ? answers.text.choice : \"__none__\";\n\n // Missing/invalid choices and exhausted controls are not evidence of success.\n const action: Decision[\"action\"] = chosenKey === \"__done__\" && goalReached >= 0.6\n ? \"done\"\n : chosenKey === \"__back__\" && recovery\n ? \"back\"\n : !chosen\n ? \"stuck\"\n : needsText && textPick !== \"__none__\"\n ? \"type\"\n : \"click\";\n\n return {\n action,\n back: action === \"back\" ? recovery : undefined,\n target: action === \"done\" || action === \"stuck\" ? undefined : chosen,\n text: action === \"type\" ? textPick : undefined,\n probability: pick?.probabilities?.[chosenKey],\n confidence: pick?.confidence,\n goalReached,\n ranked,\n considered: considered.length,\n usage: {\n input_tokens: stage1.usage.input_tokens + stage2.usage.input_tokens,\n output_tokens: stage1.usage.output_tokens + stage2.usage.output_tokens,\n },\n model: stage2.model,\n ms: Math.round(performance.now() - started),\n };\n}",[213],"e8beb710-4429-45a9-a280-26e04c9a2bd7","candidates.ts","59c0a714-b22f-11f1-a155-1607ee4eb77e",203,["D",1789605885931],"export type PageRegion = \"content\" | \"navigation\" | \"header\" | \"footer\" | \"sidebar\" | \"search\";\n\n/**\n * Reserve 75% of the budget for content and 25% for surrounding controls.\n * Borrow unused slots and preserve the extractor's order within each group.\n */\nexport function selectCandidates(\n candidates: T[],\n limit = 60,\n includeNavigation = true,\n): T[] {\n const content = candidates.filter((c) => !c.region || c.region === \"content\");\n if (!includeNavigation) return content.slice(0, limit);\n const navigation = candidates.filter((c) => c.region && c.region !== \"content\");\n const contentBudget = Math.floor(limit * 0.75);\n const navigationBudget = limit - contentBudget;\n const selected = [...content.slice(0, contentBudget), ...navigation.slice(0, navigationBudget)];\n const remaining = limit - selected.length;\n if (remaining > 0) {\n selected.push(...content.slice(contentBudget, contentBudget + remaining));\n selected.push(...navigation.slice(navigationBudget, navigationBudget + limit - selected.length));\n }\n return selected;\n}\n",[221],"660c073f-84cd-4968-adcb-acfec223869a",["D",1789605887418],23,[28],"d9823670-eb66-443f-a96c-70bc7b59c8cb","README.md","01a0abce-8571-76e1-8061-d5a5e82286cc",201,["D",1789605483076],27,"# Jev Browser Use\n\nDescribe a task. Jev picks every next move in a live cloud browser you watch in\nan iframe.\n\n## Setup\n\nTwo keys, both required:\n\n- `TYPESAFE_API_KEY` — from\n [console.typesafe.ai](https://console.typesafe.ai/settings/keys)\n- `KERNEL_API_KEY` — from\n [dashboard.onkernel.com](https://dashboard.onkernel.com/settings/api-keys)\n\nWithout them the page says which one is missing and asks nothing, rather than\nfailing on the first click. `/api/config` reports the gap.\n\n## How the demo works\n\nVal Town runs the app, Kernel supplies the remote browser, and Jev chooses\nthe next action from extracted page text and controls. The live view is\n**read-only**: you can watch the browser and action log while the agent works.\n\nEach session saves actions and observed outcomes in SQLite. Returning to the\nsame page state excludes previously attempted controls; repeating the same\ntyped action is also blocked.\n\nWhen a route stops being useful, Jev can choose **Back** if the previous\nbrowser entry has untried controls. Returning keeps explored routes excluded,\nso it can try an alternative. Back consumes a normal step.\n\nA run ends on completion, stuck, Stop, or a step/time limit. The app then\ncloses the remote browser. See [Scoring](#scoring) for how Jev evaluates\ncontrols and decides whether the goal is reached.\n\n## The loop\n\n```mermaid\nsequenceDiagram\n participant B as Browser (the page)\n participant H as index.ts (Hono)\n participant K as Kernel\n participant J as Jev\n B->>H: POST /api/step\n H->>K: playwright/execute → url, title, content text, tagged elements\n H->>H: reconcile history, filter repeats, allocate 45 content / 15 surrounding slots\n H->>J: stage 1 — two nouls per candidate: goal and useful next step\n J-->>H: two probabilities per candidate\n H->>H: score = goal + (1 - goal) * closer, keep up to 24\n H->>J: stage 2 — finalists, eligible __back__, __done__ / __stuck__\n J-->>H: chosen action, with a probability and a confidence\n H->>H: save the attempt before execution\n H->>K: move_mouse (Bézier) → click_mouse, or verified browser Back\n H-->>B: the decision and the step\n```\n\nThe **browser** drives the loop by calling `/api/step` repeatedly. That keeps\neach request short and lets the UI render every step as it lands, which is the\nwhole point of the demo.\n\n## Scoring\n\nJev uses the task, page text, recent outcomes, and each control's label,\ndestination, and region. After repeat filtering, up to 60 controls enter\nscoring: 45 content slots and 15 shared by navigation, headers, footers,\nsidebars, and search, with unused slots borrowed by the other group. Region\nis context, not a score bonus or penalty; the same guidance applies to every\ntask.\n\n| Stage | Value | Meaning and use |\n| --- | --- | --- |\n| 1 — assess each control | `goal` (0–1) | Does activating it lead directly to the page or thing the task names? |\n| 1 — assess each control | `closer` (0–1) | Is it a useful intermediate step toward the task? |\n| 1 — shortlist | `goal + (1 - goal) * closer` | Code combines both estimates and keeps up to 24 finalists. A strong answer to either question helps a control survive. |\n| 2 — choose | `next` | Jev compares the finalists and chooses one action, eligible Back, completion, or stuck. It need not choose the highest stage-1 score. |\n| 2 — check completion | `goal_reached` (0–1) | Does the current page already satisfy the task? Success requires both an explicit completion choice and a score of at least 0.6. |\n\nThe action-log percentage is Jev's probability for its **stage-2 choice**,\nnot the combined stage-1 score or a measured task-success rate. The UI also\nshows the model's separate confidence value. These are model estimates.\n\n### Why two stages\n\nStage 1 is a **filter**, not a ranking you should trust. On a fixture where the\ngoal link sits beside a plausible neighbour, stage 1 ranks the neighbour first:\n\n```\n0.708 goal 0.21 closer 0.63 Gustave Eiffel\n0.626 goal 0.22 closer 0.52 Search Wikipedia\n0.622 goal 0.38 closer 0.39 Eiffel Tower ← the goal\n```\n\nThat's fine. Stage 1 only has to keep the goal in the finalist set, and stage 2\n— which sees up to 24 finalists side by side — picks the Eiffel Tower. Two atomic\nquestions beat one compound one: the first version asked a single \"does this\nmove us closer?\", which conflates _the goal_ with _a step toward it_, and it\nclicked the biographer. Same cost either way, since questions in a request are\nevaluated in parallel.\n\nRun it yourself: [`tests/decide.ts`](url:tests/decide.ts) needs no browser.\n\n## Background\n\nEverything in this section is from [Steve](https://x.com/stevekrouse) of Val\nTown, who got this up and running — thanks, Steve.\n\n### The thing I went looking for and didn't find\n\nTypeSafe's docs have **no computer-use guide.** `docs.typesafe.ai/demos.md`\nlists exactly one demo (Smart Home Assistant). The wikiracing demo that looks\nlike computer use only exists as a launch-blog demo — no docs page, no code, no\nwalkthrough.\n\nWhat the blog _does_ say, in its \"Nuance\" sections, is the whole spec:\n\n> **Jev supports a cardinality up to 255.** For the higher cardinality choices,\n> we do a 2 stage-system of scoring independently then making an explicit\n> choice, hence the occasional slowdown.\n\n> The demo is on structured state as a data structure with **text, not on\n> images** (yet…)\n\nSo Jev never sees the screen, and it never emits an action. It has no string\noutput at all — only `choice`, `score`, `noul`. \"Browser use with Jev\" therefore\ncan't be a model emitting tool calls. It's:\n\n> **code builds a closed set out of the page → Jev ranks and chooses within it →\n> code does the clicking.**\n\nThat constraint is the design, not a workaround. Every action is a value Jev was\nhanded, so it cannot invent a selector, hallucinate a URL, or make a type error.\n\n### Three bugs a real page found\n\nThe `perceive()` snippet was measured against a live Wikipedia article, not\nreasoned about — see `@stevekrouse/browser-tester`'s `tests/jev-perceive.ts`,\nwhich runs the exact snippet. All three were real:\n\n1. **Text came from `document.body`**, which on Wikipedia is mostly furniture —\n \"Jump to content Main menu Search Appearance Donate Create account\". Jev was\n being asked to navigate a page whose text was the chrome. Now it reads the\n content root (`article`, `#mw-content-text`, …) and only falls back to the\n body.\n2. **A candidate's centre could sit below the fold.** The measured page had one\n at `y=519` in a 513px viewport — an element whose _top_ is on screen can have\n its _centre_ off it, and the centre is what gets clicked. Centres are now\n required to be inside the viewport.\n3. **Nothing below the fold was reachable at all.** Every candidate is now\n tagged with `data-jev` in the live DOM, so `act()` can scroll it into view\n and re-read where it actually is before clicking. That took the candidate\n count on the same page from **10 to 195**.\n\n## Limits, honestly\n\n- **Typing is the weak spot.** Jev can't write text, so `harvestTexts()` pulls\n quoted phrases out of _your_ task and Jev chooses which to type. A task with\n no quoted phrase can't type anything. This is the one place the no-strings\n constraint genuinely costs capability rather than buying safety.\n- **Back is bounded recovery.** Jev can choose Back when the actual previous\n browser history entry has saved, untried non-editable controls. It returns\n one entry, counts toward the step budget, and keeps explored routes excluded.\n Failed or repeated Back attempts from the same state are blocked. If the\n previous entry is unknown or exhausted, Back is not offered; the agent does\n not jump over it to older pages. Back restores navigation, not submitted\n forms or other side effects. If no useful action remains, the run reports\n \"stuck\" rather than claiming success.\n- **History sees extracted state.** It compares the URL, extracted text, and\n control identities, not screenshots. Dynamic content can make a revisited\n page look new; meaningful changes outside the extracted content can be missed.\n- **Selection is still bounded.** Region budgets keep both content and\n surrounding controls represented; they do not guarantee that every relevant\n control on a large page reaches scoring.\n- **12 steps.** `MAX_STEPS` in `index.ts`. Wikiracing often needs more.\n\n## Testing\n\nRefresh the demo and start a **fresh run** to exercise the full history and\nBack behavior. Existing sessions may lack the navigation snapshots needed to\noffer Back. Watch for a different choice after revisiting a page, an explicit\n\"go back to …\" entry when recovery is selected, and \"stuck\" when no useful\naction remains. Back is conditional; it will not appear on every run.\n\nRegression scripts can be run individually with Val Town's run-file tool:\n\n- [`tests/candidates.ts`](url:tests/candidates.ts): 15 checks for balanced\n quotas, borrowing unused slots, ordering, region context, and history\n filtering before allocation. Uses model stubs and creates no browser.\n- [`tests/regions-browser.ts`](url:tests/regions-browser.ts): 13 checks with\n generic long-page fixtures and a live Val Town pricing navigation regression.\n Covers footer controls after 320 content links and content after 320\n navigation links. Makes live Jev calls and deletes its fixture browser.\n\n- [`tests/history.ts`](url:tests/history.ts): 38 checks covering repeat\n filtering, Back eligibility, invalid choices, and SQLite persistence.\n Uses model stubs and creates no browser.\n- [`tests/back-browser.ts`](url:tests/back-browser.ts): 11 checks in a real\n Kernel browser against fixture pages, including returning to an untried\n route, rejecting stale Back decisions, and same-document navigation.\n Makes no model calls and deletes its test browser in a finally block.\n- [`tests/decide.ts`](url:tests/decide.ts): the original decision fixture;\n makes live Jev calls without creating a browser.\n\nThe candidate, history, and region/browser suites passed after the region\nchanges. The live pricing check selected Pricing from navigation and reached\nthe pricing page using the general scoring instructions. It checks navigation,\nnot extraction of the cheapest plan's price. The Back browser suite passed\nwhen recovery was added; none of these checks establishes success on every\ntask or a full Wikipedia race.\n\n## Files\n\nSee [`AGENTS.md`](url:AGENTS.md) for the file map.",[232],"ecf64b99-5fc5-4e93-a875-7f0f2046858e","AGENTS.md","01a0abce-8571-76e1-8061-cdf4a9f6fc29",198,["D",1789605333317],14,"# jev-browser-use\n\nDescribe a task. Jev picks every next move in a live cloud browser you watch in\nan iframe.\n\n## File map\n\n| Path | Type | Purpose |\n| --- | --- | --- |\n| `index.ts` | http | Hono app: shell, assets, `GET /source`, `GET /api/config`, `POST /api/session`, `POST /api/step`, `POST /api/session/:id/stop` |\n| `decide.ts` | script | The Jev half: two-stage score-then-choose over the page's controls |\n| `candidates.ts` | script | Shared 75/25 content/surrounding allocation with unused-slot borrowing |\n| `tests/candidates.ts` | script | General allocation, scoring context, and history-filter regressions |\n| `tests/regions-browser.ts` | script | Long-page region fixtures and live pricing navigation; deletes its browser |\n| `browser-use.ts` | script | The Kernel half: `perceive()` reads the page as data, `act()` clicks/types |\n| `kernel.ts` | script | Kernel REST client — browsers, live view, computer controls |\n| `sessions.ts` | script | Live-browser registry, Kernel limits, and per-session SQLite history |\n| `history.ts` | script | Page fingerprints, action identities, repeat filtering, snapshots, and Back eligibility |\n| `tests/history.ts` | script | Deterministic loop, Back eligibility, completion, and persistence checks |\n| `tests/back-browser.ts` | script | Live Kernel Back regression; creates and deletes one fixture browser |\n| `rate-limit.ts` | script | Best-effort in-memory per-IP + global burst control, bucketed per endpoint |\n| `typesafe.ts` | script | Minimal TypeSafe (System One) REST client + answer types |\n| `tests/decide.ts` | script | Runs `decide()` against a fixture page state — no browser needed |\n| `frontend/root.tsx` | script | HTML shell (Hono JSX); stamps immutable asset URLs |\n| `frontend/index.tsx` | script | React entrypoint |\n| `frontend/components/App.tsx` | script | State machine, controls, step log, `?present=1` mode |\n| `frontend/components/Stage.tsx` | script | The square stage: task, live view iframe, caption, score strip |\n| `frontend/lib/api.ts` | script | Typed client for the val's own API |\n| `frontend/favicon.svg` | file | Icon |\n\n## The loop\n\n```\nperceive() → decide() → act() → repeat\n Kernel Jev Kernel\n```\n\n`POST /api/step` runs exactly one turn, and the **browser** drives the loop by\ncalling it repeatedly. That keeps each request short and lets the UI render\nevery step as it lands — which is the whole point of the demo.\n\n## Notes\n\n- **Jev cannot emit an action.** It has no string output at all — only `choice`,\n `score`, `noul`. So this is not a model emitting tool calls: `decide.ts` builds\n a closed set out of the page, Jev ranks and chooses within it, and ordinary\n code does the clicking. That's the constraint the whole design hangs on, and\n it's why the model can't hallucinate a selector or invent a URL.\n- **Two stages, per TypeSafe's own wikiracing demo** (\"Jev supports a cardinality\n up to 255... for the higher cardinality choices, we do a 2 stage-system of\n scoring independently then making an explicit choice\"). Stage 1 asks two `noul` questions\n per candidate — a filter, it never picks. Stage 2 is one `choice` over the top\n `FINALISTS`, eligible `__back__`, `__done__`, and `__stuck__`. Constants live at the top of `decide.ts`.\n- **Regions are context, not a relevance rule.** Keep content, navigation,\n header, footer, sidebar, and search controls. Shared allocation reserves\n 45 content / 15 surrounding scoring slots and borrows unused slots; history\n filtering comes first. Collection also balances its 250 slots (187/63),\n scanning up to 250 eligible controls per group so late footer controls can\n survive a long content section. Scoring instructions are general across tasks.\n- **History is server-owned.** `history.ts` fingerprints the URL, extracted text,\n and sorted control identities. `sessions.ts` persists attempts in SQLite;\n the next observation records the outcome. Repeated non-editable controls in\n the same state are filtered before scoring. Exact repeated typed actions\n stop before execution. Invalid or exhausted choices report stuck, not success.\n- **Back is a normal, budgeted action.** Perception reads Chromium history entry\n IDs via CDP. Back is offered only when the immediately previous entry has a\n saved snapshot with untried non-editable controls. Execution rechecks both\n entry IDs and the destination URL, calls Playwright goBack, and verifies the\n resulting entry (a null HTTP response is valid for same-document navigation).\n Back attempts are saved before execution; failures and repeats are excluded.\n Older sessions without navigation snapshots cannot offer Back until a known\n parent snapshot exists. Browser navigation does not undo side effects.\n- **Jev never sees the screen.** It gets `{ url, title, visible_text, candidates }`\n as text, plus the goal and recent actions. No screenshots — matching the blog's\n note that the Doom demo runs \"on structured state as a data structure with\n text, not on images (yet…)\".\n- **Typing is the one thing Jev can't source.** It can't write text, so\n `harvestTexts()` pulls quoted phrases out of the user's own task and Jev\n *chooses* which to type. A task with no quoted phrase simply can't type.\n- **Kiosk mode is load-bearing, not cosmetic.** It removes the browser chrome so\n the window *is* the page viewport, which makes `getBoundingClientRect()`\n coordinates equal the screen coordinates the computer controls click. With\n chrome in the way every click lands a toolbar-height too high.\n- **Clicking always moves the cursor first**, via `moveMouse` with Kernel's\n default Bézier path. It's not just for the video — hover-sensitive menus\n ignore a click at coordinates the cursor never visited.\n- **`rate-limit.ts` is burst control**, bucketed per endpoint so a burst of steps\n can't exhaust the allowance for starting a browser: 6/min per IP and 60/min\n globally on `/api/session`, 90/min and 300/min on `/api/step`.\n- **The browser is the thing that can run away**, so the limits are aimed at it —\n a browser keeps running after the request that made it returns.\n - `MAX_SESSION_SECONDS` (**180**) caps one browser's life. `MAX_STEPS` bounds\n the work a run does, not the time it takes — steps are what keep a browser\n alive, so a client looping on `/api/step` could otherwise hold one open\n indefinitely.\n - `sweepStaleSessions` closes browsers whose clients walked away: nothing else\n notices them, because `/api/step` is what keeps a run moving. It runs\n opportunistically on session creation, *before* the live count is taken, so\n an abandoned browser can't hold a concurrency slot forever.\n *Known gap:* if nobody starts a session, the row sits `live` until the next\n one does. Kernel's 240s idle timeout still deletes the browser itself, so\n it's a stale row rather than a browser that outlives its welcome.\n - `MAX_LIVE_SESSIONS` is **5**, matching Kernel's Developer-tier ceiling of 5\n concurrent browsers. Above that the sixth `createBrowser` is refused by\n Kernel rather than by this guard, so raise it only with a Kernel plan that\n allows more. Override with `MAX_LIVE_SESSIONS`; a value that isn't a positive\n integer falls back to 5 rather than to NaN, which would disable the cap\n entirely.\n- **Browsers must be deleted, not abandoned.** `finish()` closes the session row\n and deletes the browser at Kernel. It's called on done, on stop, on step-limit,\n on the session time cap, and on error. The client also stops the session in a\n `finally`, so a loop that exits early can't leave a browser running. Kernel's\n `timeout_seconds` (240s idle) is the backstop.\n- `data-*` hooks for Playwright: `data-stage`, `data-task`, `data-caption`,\n `data-status`, `data-scores`, `data-live-view`, `data-log`, `data-log-entry`,\n `data-task-input`, `data-url-input`, `data-run`, `data-stop`.\n- `?present=1` renders only the square stage, sized to the viewport. That's the\n mode to screen-record.\n- Env: `TYPESAFE_API_KEY` (https://console.typesafe.ai/settings/keys) and\n `KERNEL_API_KEY` (https://dashboard.onkernel.com/settings/api-keys). Both are\n required; `/api/config` reports which are missing and the page says so up front.",[240],"a6c4385d-8c86-4d90-bb2f-e40fa8f5ad86","tests","01a0abce-8571-76e1-8061-ca995244ffd6",["D",1789588833583],"directory",[248],"547cc93c-0b46-4b3d-b204-3199dbf1b11e","frontend","01a0abce-8571-76e1-8061-c0e52b5be3b5",["D",1789588833583],[254],"pulls","branches","forks","envVars",{"_265":185,"_267":65},"connections",{"_265":65,"_266":65},"count","unfilledCount","emptyCount",{"_43":253,"_32":254,"_30":255,"_165":-5,"_41":42,"_40":166,"_167":61,"_38":447,"_13":65,"_33":251,"_35":-5,"_24":25,"_170":-5,"_297":448,"_27":449},{"_43":443,"_32":434,"_30":428,"_165":255,"_41":42,"_40":166,"_167":61,"_38":444,"_13":65,"_33":251,"_35":-5,"_24":25,"_170":-5,"_297":445,"_27":446},{"_43":435,"_32":436,"_30":437,"_165":428,"_41":42,"_40":438,"_167":25,"_38":439,"_13":177,"_33":34,"_35":440,"_24":25,"_170":-5,"_297":441,"_27":442},{"_43":425,"_32":426,"_30":427,"_165":428,"_41":42,"_40":429,"_167":25,"_38":430,"_13":193,"_33":34,"_35":431,"_24":25,"_170":-5,"_297":432,"_27":433},{"_43":421,"_32":420,"_30":414,"_165":255,"_41":42,"_40":166,"_167":61,"_38":422,"_13":65,"_33":251,"_35":-5,"_24":25,"_170":-5,"_297":423,"_27":424},{"_43":411,"_32":412,"_30":413,"_165":414,"_41":42,"_40":415,"_167":25,"_38":416,"_13":177,"_33":34,"_35":417,"_24":25,"_170":-5,"_297":418,"_27":419},{"_43":403,"_32":404,"_30":405,"_165":255,"_41":42,"_40":406,"_167":61,"_38":407,"_13":166,"_33":20,"_35":408,"_24":25,"_170":-5,"_297":409,"_27":410},{"_43":395,"_32":396,"_30":397,"_165":255,"_41":42,"_40":398,"_167":61,"_38":399,"_13":166,"_33":34,"_35":400,"_24":25,"_170":-5,"_297":401,"_27":402},{"_43":387,"_32":388,"_30":389,"_165":255,"_41":42,"_40":390,"_167":25,"_38":391,"_13":166,"_33":34,"_35":392,"_24":25,"_170":-5,"_297":393,"_27":394},{"_43":247,"_32":248,"_30":249,"_165":-5,"_41":42,"_40":166,"_167":61,"_38":384,"_13":65,"_33":251,"_35":-5,"_24":25,"_170":-5,"_297":385,"_27":386},{"_43":376,"_32":377,"_30":378,"_165":249,"_41":42,"_40":379,"_167":25,"_38":380,"_13":65,"_33":34,"_35":381,"_24":25,"_170":-5,"_297":382,"_27":383},{"_43":368,"_32":369,"_30":370,"_165":249,"_41":42,"_40":371,"_167":61,"_38":372,"_13":65,"_33":34,"_35":373,"_24":25,"_170":-5,"_297":374,"_27":375},{"_43":361,"_32":221,"_30":362,"_165":249,"_41":42,"_40":363,"_167":61,"_38":364,"_13":166,"_33":34,"_35":365,"_24":25,"_170":-5,"_297":366,"_27":367},{"_43":353,"_32":213,"_30":354,"_165":249,"_41":42,"_40":355,"_167":61,"_38":356,"_13":357,"_33":34,"_35":358,"_24":25,"_170":-5,"_297":359,"_27":360},{"_43":346,"_32":205,"_30":347,"_165":249,"_41":42,"_40":348,"_167":61,"_38":349,"_13":185,"_33":34,"_35":350,"_24":25,"_170":-5,"_297":351,"_27":352},{"_43":338,"_32":339,"_30":340,"_165":249,"_41":42,"_40":341,"_167":61,"_38":342,"_13":65,"_33":34,"_35":343,"_24":25,"_170":-5,"_297":344,"_27":345},{"_43":330,"_32":331,"_30":332,"_165":249,"_41":42,"_40":333,"_167":61,"_38":334,"_13":65,"_33":34,"_35":335,"_24":25,"_170":-5,"_297":336,"_27":337},{"_43":239,"_32":240,"_30":241,"_165":-5,"_41":42,"_40":242,"_167":25,"_38":327,"_13":244,"_33":20,"_35":245,"_24":25,"_170":-5,"_297":328,"_27":329},{"_43":231,"_32":232,"_30":233,"_165":-5,"_41":42,"_40":234,"_167":25,"_38":324,"_13":236,"_33":20,"_35":237,"_24":25,"_170":-5,"_297":325,"_27":326},{"_43":227,"_32":28,"_30":31,"_165":-5,"_41":42,"_40":14,"_167":25,"_38":321,"_13":229,"_33":34,"_35":37,"_24":25,"_170":-5,"_297":322,"_27":323},{"_43":220,"_32":221,"_30":222,"_165":-5,"_41":42,"_40":223,"_167":61,"_38":318,"_13":185,"_33":34,"_35":225,"_24":25,"_170":-5,"_297":319,"_27":320},{"_43":212,"_32":213,"_30":214,"_165":-5,"_41":42,"_40":215,"_167":61,"_38":315,"_13":217,"_33":34,"_35":218,"_24":25,"_170":-5,"_297":316,"_27":317},{"_43":204,"_32":205,"_30":206,"_165":-5,"_41":42,"_40":207,"_167":61,"_38":312,"_13":209,"_33":34,"_35":210,"_24":25,"_170":-5,"_297":313,"_27":314},{"_43":196,"_32":197,"_30":59,"_165":-5,"_41":42,"_40":198,"_167":25,"_38":309,"_13":200,"_33":201,"_35":202,"_24":25,"_170":45,"_297":310,"_27":311},{"_43":188,"_32":189,"_30":190,"_165":-5,"_41":42,"_40":191,"_167":61,"_38":306,"_13":193,"_33":34,"_35":194,"_24":25,"_170":-5,"_297":307,"_27":308},{"_43":180,"_32":181,"_30":182,"_165":-5,"_41":42,"_40":183,"_167":61,"_38":303,"_13":185,"_33":34,"_35":186,"_24":25,"_170":-5,"_297":304,"_27":305},{"_43":172,"_32":173,"_30":174,"_165":-5,"_41":42,"_40":175,"_167":25,"_38":300,"_13":177,"_33":34,"_35":178,"_24":25,"_170":-5,"_297":301,"_27":302},{"_43":162,"_32":163,"_30":164,"_165":-5,"_41":42,"_40":166,"_167":61,"_38":296,"_13":65,"_33":34,"_35":169,"_24":25,"_170":-5,"_297":298,"_27":299},["D",1789588833583],"children",[],[163],["D",1789603885050],[],[173],["D",1789599861763],[],[181],["D",1789599875697],[],[189],["D",1789604447305],[],[197],["D",1789604411595],[],[205],["D",1789605211052],[],[213],["D",1789605885931],[],[221],["D",1789605887418],[],[28],["D",1789605483076],[],[232],["D",1789605333317],[],[240],"359673ed-ad5b-4a17-9d06-890640605ab2","regions-browser.ts","93b64320-b22f-11f1-8e74-1607ee4eb77e",190,["D",1789605283649],"/**\n * One short-lived Kernel browser: generic region fixtures, then a live pricing\n * navigation regression. Makes live Jev calls and always deletes the browser.\n */\nimport { createBrowser, destroyBrowser, runPlaywright } from \"../kernel.ts\";\nimport { perceive, act } from \"../browser-use.ts\";\nimport { selectCandidates } from \"../candidates.ts\";\nimport { decide } from \"../decide.ts\";\nfunction check(ok: unknown, message: string) { if (!ok) throw new Error(message); console.log(\"PASS\", message); }\nconst browser = await createBrowser({name:\"jev-region-regression\",idleTimeoutSec:60});\ntry {\n const links = Array.from({length:320},(_,i)=>'Item '+i+'
').join(\"\");\n const html = '

'+links+'

';\n const fixture = await runPlaywright(browser.session_id, 'await page.setContent('+JSON.stringify(html)+'); return true;');\n if (!fixture.success) throw new Error(fixture.error);\n const page = await perceive(browser.session_id);\n check(page.candidates.length === 250, \"long fixture respects the collection cap\");\n for (const [label, region] of [[\"Account\",\"header\"],[\"Catalog\",\"navigation\"],[\"Related\",\"sidebar\"],[\"Search\",\"search\"],[\"Help\",\"footer\"],[\"Policy\",\"navigation\"]]) {\n check(page.candidates.some(c=>c.label===label && c.region===region), \"extractor retains and tags \"+region+\" controls\");\n }\n const shortlist = selectCandidates(page.candidates);\n check(shortlist.some(c=>c.label===\"Help\") && shortlist.length===60, \"footer after 320 content links reaches scoring\");\n check(shortlist.filter(c=>c.region===\"content\").length===54, \"unused surrounding slots are filled with content\");\n\n const navHeavy = '

Read article

';\n const second = await runPlaywright(browser.session_id, 'await page.setContent('+JSON.stringify(navHeavy)+'); return true;');\n if (!second.success) throw new Error(second.error);\n const navPage = await perceive(browser.session_id);\n check(selectCandidates(navPage.candidates).some(c=>c.label===\"Read article\"), \"content after 320 navigation links still reaches scoring\");\n\n const live = await runPlaywright(browser.session_id, 'await page.goto(\"https://www.val.town/\", {waitUntil:\"domcontentloaded\"}); await page.waitForSelector(\\'a[href=\"/pricing\"]\\'); return true;');\n if (!live.success) throw new Error(live.error);\n const home = await perceive(browser.session_id);\n check(selectCandidates(home.candidates).some(c=>c.href===\"/pricing\"), \"live Pricing link reaches scoring\");\n const decision = await decide(home, \"Find the pricing page and tell me what the cheapest paid plan costs.\", []);\n console.log(\"Live decision:\", decision.action, decision.target?.label, decision.target?.href, decision.target?.region);\n check(decision.action===\"click\" && new URL(decision.target?.href??\"\",home.url).pathname===\"/pricing\", \"Jev selects Pricing with the generic scoring instructions\");\n await act(browser.session_id,decision);\n const arrived = await runPlaywright(browser.session_id, 'await page.waitForURL(\"**/pricing\", {timeout:10000}); return {url:page.url()};');\n check(arrived.success, \"live browser reaches the pricing page\");\n console.log(\"13 region/browser checks passed.\");\n} finally {\n await destroyBrowser(browser.session_id);\n console.log(\"Test browser deleted.\");\n}\n",[],[248,331],"e355643f-3c29-4b27-8676-85d879ad3c39","key-check.ts","211a7fca-b20c-11f1-905e-1607ee4eb77e",44,["D",1789590058985],"/**\n * Diagnostic for a rejected KERNEL_API_KEY.\n *\n * Prints the key's *shape* and never the key: length, whether it carries stray\n * whitespace or quote characters, and a 4-byte hash prefix. The hash prefix is\n * the point — running this same file in another val and comparing the two\n * prefixes answers \"are these the same key?\" without either val revealing its\n * value.\n *\n * Then it asks Kernel directly with a read-only GET, so the raw status and body\n * are visible rather than paraphrased.\n *\n * Run with `run_file`. Creates nothing and spends nothing.\n */\nconst raw = Deno.env.get(\"KERNEL_API_KEY\");\nconst key = raw?.trim() ?? \"\";\n\nasync function hashPrefix(s: string): Promise {\n const buf = await crypto.subtle.digest(\n \"SHA-256\",\n new TextEncoder().encode(s),\n );\n return [...new Uint8Array(buf)]\n .slice(0, 4)\n .map((b) => b.toString(16).padStart(2, \"0\"))\n .join(\"\");\n}\n\nconsole.log(\"var present: \", raw !== undefined);\nconsole.log(\"raw length: \", raw?.length ?? 0);\nconsole.log(\"trimmed length: \", key.length);\nconsole.log(\"had surrounding whitespace:\", raw !== undefined && raw !== key);\nconsole.log(\"contains any whitespace: \", /\\s/.test(key));\nconsole.log(\"contains a quote char: \", /[\"'`]/.test(key));\nconsole.log(\"contains a colon or comma:\", /[:,]/.test(key));\nconsole.log(\"hash prefix: \", await hashPrefix(key));\n\n// Read-only, so this can't create a browser or cost anything.\nconst res = await fetch(\"https://api.onkernel.com/browsers\", {\n headers: { Authorization: `Bearer ${key}` },\n});\nconsole.log(\"\\nkernel GET /browsers status:\", res.status);\nconsole.log(\"kernel body:\", (await res.text()).slice(0, 400));",[],[248,339],"86e30287-7d83-4532-9a1f-44e4d4b54dd1","962caec6-b22c-11f1-8f57-1607ee4eb77e",153,["D",1789604478627],"/**\n * Deterministic regression tests: no model calls or cloud browsers.\n * Run with Val Town's run_file.\n */\nimport { decide, type Candidate, type Decision, type PageState } from \"../decide.ts\";\nimport { actionKey, availableCandidates, backOption, observePrevious, pageKey, repeatedAction, rememberAttempt, targetKey, type HistoryStep } from \"../history.ts\";\nimport { getHistory, saveHistory } from \"../sessions.ts\";\nimport { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\nimport type { ask, Answer } from \"../typesafe.ts\";\n\nlet passed = 0;\nfunction check(ok: unknown, message: string) {\n if (!ok) throw new Error(message);\n passed++;\n console.log(\"PASS\", message);\n}\nconst link = (n: number, label: string, href: string): Candidate =>\n ({ n, dom: n, tag: \"a\", label, href, x: 10, y: 20 });\nconst buildings = link(0, \"buildings\", \"/wiki/Building\");\nconst tower = link(1, \"Eiffel Tower\", \"/wiki/Eiffel_Tower\");\nconst architecture: PageState = {\n url: \"https://en.wikipedia.org/wiki/Architecture\",\n title: \"Architecture\",\n text: \"Architecture is the art of designing buildings.\",\n candidates: [buildings, tower],\n};\nconst state = await pageKey(architecture);\nconst record: HistoryStep = {\n state, url: architecture.url, target: targetKey(buildings, architecture.url),\n action: JSON.stringify([\"click\", targetKey(buildings, architecture.url), \"\"]),\n description: 'click \"buildings\"', outcome: \"changed\",\n afterUrl: \"https://en.wikipedia.org/wiki/Building\",\n};\nconst memory = { state, steps: [record] };\nconst returned = {\n ...architecture,\n candidates: [tower, { ...buildings, n: 99, dom: 88, y: 500, label: \"Building\", href: \"https://en.wikipedia.org/wiki/Building\" }],\n};\ncheck(await pageKey(returned) === state, \"state survives scrolling, reordering, link aliases, and new DOM indexes\");\ncheck(availableCandidates(returned, memory).length === 1, \"Architecture → Buildings → Architecture cannot select Buildings again\");\ncheck(availableCandidates(returned, memory)[0].label === \"Eiffel Tower\", \"untried route remains available\");\ncheck(availableCandidates(architecture, { state, steps: [] }).length === 2, \"a separate run has no inherited exclusions\");\nconst changed = { ...architecture, text: \"Architecture — a new dialog is open.\" };\ncheck(await pageKey(changed) !== state, \"same URL with changed content is a different state\");\ncheck(availableCandidates(changed, { state: await pageKey(changed), steps: [record] }).length === 2, \"changed state permits a legitimate reuse\");\ncheck(await pageKey({ ...architecture, url: architecture.url + \"?page=2\" }) !== state, \"query parameters remain meaningful\");\n\nconst pending = { ...record, outcome: \"pending\" as const, afterUrl: undefined };\nconst steps: HistoryStep[] = [pending];\nobservePrevious(steps, architecture, state);\ncheck(steps[0].outcome === \"unchanged\", \"no-effect action is observed on the next step\");\nconst failed: HistoryStep = { ...record, outcome: \"error\", error: \"click failed\", afterUrl: undefined };\nobservePrevious([failed], architecture, state);\ncheck(failed.outcome === \"error\" && failed.afterUrl === architecture.url, \"observing a failed click preserves its error\");\n\nconst field: Candidate = { n: 2, dom: 2, tag: \"input\", label: \"Search\", editable: true, x: 0, y: 0 };\nconst typing = { action: \"type\", target: field, text: \"architecture\" } as Decision;\nconst typedRecord = { ...record, target: targetKey(field, architecture.url), action: actionKey(typing, architecture.url) };\ncheck(repeatedAction(typing, architecture, { state, steps: [typedRecord] }), \"identical typed action is blocked\");\ncheck(!repeatedAction({ ...typing, text: \"Eiffel Tower\" }, architecture, { state, steps: [typedRecord] }), \"different typed value is allowed\");\n\nfunction fakeModel(choice: string | undefined, goal: number): typeof ask {\n return async (_state, questions) => {\n const answers: Record = {};\n for (const key of Object.keys(questions)) {\n answers[key] = { type: \"noul\", noul: 0.8 };\n }\n if (questions.next) {\n delete answers.next;\n if (choice !== undefined) answers.next = { type: \"choice\", choice, probabilities: { [choice]: 1 }, confidence: 1 };\n answers.goal_reached = { type: \"noul\", noul: goal };\n }\n return { model: \"test\", answers, usage: { input_tokens: 0, output_tokens: 0 } };\n };\n}\nconst result = await decide(returned, \"Reach the Eiffel Tower\", [], memory, fakeModel(\"c1\", 0));\ncheck(result.target?.label === \"Eiffel Tower\" && result.considered === 1, \"decision pipeline filters repeated route before model scoring\");\nfor (const choice of [undefined, \"bogus\", \"__stuck__\", \"__done__\"]) {\n const result = await decide(architecture, \"Reach the Eiffel Tower\", [], memory, fakeModel(choice, 0));\n check(result.action === \"stuck\", \"unsupported success is stuck: \" + String(choice));\n}\nconst success = await decide(architecture, \"Reach Architecture\", [], memory, fakeModel(\"__done__\", 0.9));\ncheck(success.action === \"done\", \"explicit supported success still works\");\nconst allTried = { ...memory, steps: [...memory.steps, { ...record, target: targetKey(tower, architecture.url) }] };\nconst exhausted = await decide(architecture, \"Reach the Eiffel Tower\", [], allTried, fakeModel(\"__stuck__\", 0));\ncheck(exhausted.action === \"stuck\" && exhausted.considered === 0, \"exhausted choices stop without success\");\n\nconst many = { ...architecture, candidates: Array.from({length: 61}, (_, n) => link(n, \"link\" + n, \"/wiki/Page\" + n)) };\nconst manyState = await pageKey(many);\nconst manyMemory = { state: manyState, steps: many.candidates.slice(0, 60).map((c) => ({ ...record, state: manyState, target: targetKey(c, many.url) })) };\nconst sixtyFirst = await decide(many, \"Continue\", [], manyMemory, fakeModel(\"c60\", 0));\ncheck(sixtyFirst.target?.n === 60, \"filtering before the 60-candidate cap exposes an untried alternative\");\n\nconst sessionId = \"history-test-\" + crypto.randomUUID();\ntry {\n check((await getHistory(sessionId)).length === 0, \"new session history is empty\");\n await saveHistory(sessionId, [record]);\n check((await getHistory(sessionId))[0].target === record.target, \"history persists across database reads\");\n await saveHistory(sessionId, [record, failed]);\n check((await getHistory(sessionId)).length === 2, \"history updates existing session record\");\n} finally {\n await sqlite.execute({ sql: \"DELETE FROM run_history WHERE session_id = ?\", args: [sessionId] });\n}\n\nconst parent = {\n ...architecture,\n navigation: { currentId: 10 },\n};\nconst parentRecord = rememberAttempt(parent, state, { action: \"click\", target: buildings } as Decision, 'click \"buildings\"');\nconst child: PageState = {\n url: \"https://en.wikipedia.org/wiki/Building\", title: \"Buildings\", text: \"A dead end.\",\n candidates: [],\n navigation: { currentId: 11, previous: { id: 10, url: parent.url } },\n};\nconst childState = await pageKey(child);\nconst childMemory = { state: childState, steps: [parentRecord] };\ncheck(!backOption(parent, { state, steps: [] }), \"first page never offers Back\");\ncheck(!backOption({ ...child, navigation: undefined }, childMemory), \"unavailable browser history disables Back\");\ncheck(!backOption(child, { state: childState, steps: [record] }), \"legacy history without a browser entry is not guessed\");\ncheck(!backOption({ ...child, navigation: { currentId: 11, previous: { id: 999, url: parent.url } } }, childMemory), \"matching URL with wrong history entry is not sufficient\");\nconst back = backOption(child, childMemory);\ncheck(back?.entryId === 10 && back.alternatives.includes(\"Eiffel Tower\"), \"Back offers the actual prior entry with untried alternatives\");\nconst chooseBack: typeof ask = async (input, questions) => {\n if (questions.next?.type === \"choice\") check(!!questions.next.criteria.__back__, \"Back is explicitly offered to Jev\");\n return fakeModel(\"__back__\", 0)(input, questions);\n};\nconst recovery = await decide(child, \"Reach the Eiffel Tower\", [], childMemory, chooseBack);\ncheck(recovery.action === \"back\" && recovery.back?.entryId === 10 && !recovery.target, \"Jev can choose Back with no current controls\");\nconst forged = await decide(parent, \"Reach the Eiffel Tower\", [], { state, steps: [] }, fakeModel(\"__back__\", 0));\ncheck(forged.action === \"stuck\", \"model cannot choose Back when it was not offered\");\nconst spentParent = { state: childState, steps: [parentRecord, rememberAttempt(parent, state, { action: \"click\", target: tower } as Decision, 'click \"Eiffel Tower\"')] };\ncheck(!backOption(child, spentParent), \"fully explored parent does not offer Back\");\nconst backRecord = rememberAttempt(child, childState, recovery, \"go back\");\nconst afterBack = { state, steps: [parentRecord, backRecord] };\nobservePrevious(afterBack.steps, parent, state);\ncheck(availableCandidates(parent, afterBack).every((c) => c.href !== buildings.href), \"returning with Back keeps the dead-end route excluded\");\ncheck(afterBack.steps[1].outcome === \"changed\", \"Back outcome is reconciled like other actions\");\nconst failedBack = { ...backRecord, outcome: \"error\" as const, error: \"Back failed\" };\ncheck(!backOption(child, { state: childState, steps: [parentRecord, failedBack] }), \"failed Back cannot retry forever from the same state\");\ncheck(repeatedAction(recovery, child, { state: childState, steps: [parentRecord, backRecord] }), \"Back participates in repeat-action guard\");\nconst withControls = { ...child, candidates: [tower] };\nconst forward = await decide(withControls, \"Reach the Eiffel Tower\", [], childMemory, fakeModel(\"c1\", 0));\ncheck(forward.action === \"click\" && !forward.back, \"forward action remains available alongside recovery\");\nconst sameUrlChild = { ...child, url: parent.url, text: \"New application state\" };\ncheck(!!backOption(sameUrlChild, { state: await pageKey(sameUrlChild), steps: [parentRecord] }), \"same-URL history entry can still offer Back\");\nconst sameStateRecord = { ...parentRecord, state: childState };\ncheck(!backOption(child, { state: childState, steps: [sameStateRecord, { ...failedBack, state: childState }] }), \"failed recovery stays blocked even if parent fingerprint matches\");\n\nconsole.log(passed + \" history regression checks passed.\");\n",[],[248,205],"cbf3f73f-ec9c-4b0f-8dbe-76239bd2aefb","f9ab0b50-b209-11f1-b19e-1607ee4eb77e",84,["D",1789599867235],4,"/**\n * Exercises `decide()` against a fixture page state, with no browser involved.\n *\n * This is the cheap half of the loop to test and the expensive half to get\n * wrong: if stage 1 can't rank the goal link to the top of a Wikipedia article,\n * nothing downstream matters. The fixture deliberately contains the goal\n * (\"Eiffel Tower\") alongside ~20 plausible distractors, so the expected answer\n * is checkable by eye.\n *\n * Run with `run_file`. Makes two Jev calls.\n */\nimport { decide, harvestTexts, type PageState } from \"../decide.ts\";\n\nconst page: PageState = {\n url: \"https://en.wikipedia.org/wiki/Rubber_duck\",\n title: \"Rubber duck - Wikipedia\",\n text:\n \"A rubber duck is a toy shaped like a stylised yellow-billed duck, \" +\n \"usually made of rubber or rubber-like material such as vinyl plastic. \" +\n \"It is a popular bathtub toy. The rubber duck has become a cultural icon, \" +\n \"appearing in art, music, and software engineering (see rubber duck debugging).\",\n candidates: [\n { n: 0, tag: \"a\", label: \"Toy\", href: \"/wiki/Toy\", x: 100, y: 200 },\n { n: 1, tag: \"a\", label: \"Duck\", href: \"/wiki/Duck\", x: 100, y: 220 },\n { n: 2, tag: \"a\", label: \"Rubber\", href: \"/wiki/Rubber\", x: 100, y: 240 },\n { n: 3, tag: \"a\", label: \"Plastic\", href: \"/wiki/Plastic\", x: 100, y: 260 },\n { n: 4, tag: \"a\", label: \"Bathtub\", href: \"/wiki/Bathtub\", x: 100, y: 280 },\n { n: 5, tag: \"a\", label: \"Cultural icon\", href: \"/wiki/Cultural_icon\", x: 100, y: 300 },\n { n: 6, tag: \"a\", label: \"Rubber duck debugging\", href: \"/wiki/Rubber_duck_debugging\", x: 100, y: 320 },\n { n: 7, tag: \"a\", label: \"Sesame Street\", href: \"/wiki/Sesame_Street\", x: 100, y: 340 },\n { n: 8, tag: \"a\", label: \"Ernie\", href: \"/wiki/Ernie\", x: 100, y: 360 },\n { n: 9, tag: \"a\", label: \"Vulcanization\", href: \"/wiki/Vulcanization\", x: 100, y: 380 },\n { n: 10, tag: \"a\", label: \"Charles Goodyear\", href: \"/wiki/Charles_Goodyear\", x: 100, y: 400 },\n { n: 11, tag: \"a\", label: \"Paris\", href: \"/wiki/Paris\", x: 100, y: 420 },\n { n: 12, tag: \"a\", label: \"Eiffel Tower\", href: \"/wiki/Eiffel_Tower\", x: 100, y: 440 },\n { n: 13, tag: \"a\", label: \"France\", href: \"/wiki/France\", x: 100, y: 460 },\n { n: 14, tag: \"a\", label: \"Tourism\", href: \"/wiki/Tourism\", x: 100, y: 480 },\n { n: 15, tag: \"a\", label: \"Gustave Eiffel\", href: \"/wiki/Gustave_Eiffel\", x: 100, y: 500 },\n { n: 16, tag: \"a\", label: \"World's fair\", href: \"/wiki/World%27s_fair\", x: 100, y: 520 },\n { n: 17, tag: \"a\", label: \"Landmark\", href: \"/wiki/Landmark\", x: 100, y: 540 },\n { n: 18, tag: \"a\", label: \"Iron\", href: \"/wiki/Iron\", x: 100, y: 560 },\n { n: 19, tag: \"a\", label: \"Tokyo Tower\", href: \"/wiki/Tokyo_Tower\", x: 100, y: 580 },\n { n: 20, tag: \"input\", label: \"Search Wikipedia\", editable: true, x: 100, y: 40 },\n ],\n};\n\nconst task = \"Reach the article about the Eiffel Tower, using only links on the page.\";\n\nconsole.log(\"harvestTexts:\", harvestTexts(task));\n\nconst started = performance.now();\nconst decision = await decide(page, task, []);\n\nconsole.log(`\\ndecided in ${decision.ms}ms (wall ${Math.round(performance.now() - started)}ms)`);\nconsole.log(`model ${decision.model} · ${decision.considered} candidates scored`);\nconsole.log(\n `usage ${decision.usage.input_tokens} in / ${decision.usage.output_tokens} out`,\n);\n\nconsole.log(`\\naction: ${decision.action}`);\nconsole.log(`target: ${decision.target ? `\"${decision.target.label}\"` : \"(none)\"}`);\nconsole.log(`text: ${decision.text ?? \"(none)\"}`);\nconsole.log(\n `picked ${decision.probability?.toFixed(3) ?? \"?\"}` +\n ` · confidence ${decision.confidence?.toFixed(3) ?? \"?\"}` +\n ` · goal_reached ${decision.goalReached.toFixed(3)}`,\n);\n\nconsole.log(\"\\nstage 1, best first (score = goal + (1-goal)*closer):\");\nfor (const { candidate, goal, closer, score } of decision.ranked.slice(0, 8)) {\n console.log(\n ` ${score.toFixed(3)} goal ${goal.toFixed(2)} closer ${closer.toFixed(2)} ${candidate.label}`,\n );\n}\n\n// Two assertions, and deliberately not \"stage 1 ranked the goal first\".\n//\n// Stage 1 is a *filter*, and a noisy one: on this fixture it puts \"Gustave\n// Eiffel\" (goal 0.21, closer 0.63) above the goal link itself (goal 0.38,\n// closer 0.39). That's fine and is the point of the two-stage split — the\n// filter only has to keep the goal in the finalist set, and stage 2, which\n// sees all the finalists side by side, is what actually chooses.\nconst FINALISTS = 24;\nconst finalistLabels = decision.ranked.slice(0, FINALISTS).map((r) => r.candidate.label);\nconsole.log(\n `\\ngoal link survived the filter: ${finalistLabels.includes(\"Eiffel Tower\")}`,\n);\nconsole.log(`chose the goal link: ${decision.target?.label === \"Eiffel Tower\"}`);\nconsole.log(`did not stop immediately: ${decision.action !== \"done\"}`);",[],[248,213],"f0e6d738-438c-4135-ae12-7b85ea6ad5a5","81ff84e8-b22f-11f1-87e0-1607ee4eb77e",189,["D",1789605263268],"/** Generic allocation/scoring regressions. No live model or browser calls. */\nimport { selectCandidates, type PageRegion } from \"../candidates.ts\";\nimport { decide, type Candidate, type PageState } from \"../decide.ts\";\nimport { pageKey, targetKey } from \"../history.ts\";\nimport type { ask, Answer } from \"../typesafe.ts\";\nlet count = 0;\nfunction check(ok: unknown, message: string) { if (!ok) throw new Error(message); count++; console.log(\"PASS\", message); }\nconst candidates = (n: number, region?: PageRegion, offset = 0): Candidate[] =>\n Array.from({length: n}, (_, i) => ({\n n: offset + i, dom: offset + i, label: \"Control \" + (offset + i), tag: \"a\",\n href: \"/route/\" + (offset + i), x: 20, y: 20 + i, region,\n }));\nconst content = candidates(100, \"content\");\nconst nav = candidates(100, \"navigation\", 100);\nconst isContent = (c: Candidate) => !c.region || c.region === \"content\";\nconst chosen = selectCandidates([...nav, ...content]);\ncheck(chosen.length === 60 && chosen.filter(isContent).length === 45, \"navigation-first DOM still reserves 45 content and 15 surrounding controls\");\ncheck(selectCandidates([...content, ...nav]).filter(c => !isContent(c)).length === 15, \"long content preserves navigation representation\");\nconst fewContent = selectCandidates([...content.slice(0, 10), ...nav]);\ncheck(fewContent.length === 60 && fewContent.filter(isContent).length === 10, \"navigation borrows unused content slots\");\nconst fewNav = selectCandidates([...content, ...nav.slice(0, 5)]);\ncheck(fewNav.length === 60 && fewNav.filter(isContent).length === 55, \"content borrows unused navigation slots\");\ncheck(selectCandidates(content).length === 60 && selectCandidates(nav).length === 60, \"single-region pages can use all 60 slots\");\ncheck(selectCandidates([...content.slice(0, 3), ...nav.slice(0, 2)]).length === 5, \"small pages retain all controls\");\ncheck(selectCandidates(candidates(70)).length === 60, \"older fixtures without region remain compatible\");\ncheck(new Set(chosen.map(c => c.n)).size === 60, \"allocation does not duplicate controls\");\ncheck(chosen.filter(isContent).every((c, i) => c === content[i]), \"content retains viewport ordering\");\ncheck(chosen.filter(c => !isContent(c)).every((c, i) => c === nav[i]), \"surrounding controls retain viewport ordering\");\nconst collection = selectCandidates([...candidates(250, \"content\"), ...candidates(250, \"footer\", 250)], 250);\ncheck(collection.length === 250 && collection.filter(c => c.region === \"footer\").length === 63, \"250-control collection keeps a footer pool before scoring\");\n\nconst page: PageState = {url: \"https://fixture.invalid/\", title: \"Fixture\", text: \"Generic task context\", candidates: [...content, ...nav]};\nconst state = await pageKey(page);\nconst memory = {state, steps: content.slice(0, 45).map(c => ({\n state, url: page.url, target: targetKey(c, page.url), action: \"click\", description: \"click\", outcome: \"changed\" as const,\n}))};\nlet scoredKeys: string[] = [];\nlet sawRegions = false;\nlet sawGeneralGuidance = false;\nconst fake: typeof ask = async (_state, questions) => {\n const answers: Record = {};\n if (!questions.next) {\n scoredKeys = Object.keys(questions);\n sawRegions = Object.values(questions).some(q => q.instructions.includes(\"region: navigation\"));\n sawGeneralGuidance = Object.values(questions).every(q => q.instructions.includes(\"Do not favor or reject a control solely because of its region\"));\n }\n for (const key of Object.keys(questions)) answers[key] = {type:\"noul\", noul:key === \"g100\" || key === \"c100\" ? 0.99 : 0.5};\n if (questions.next) {\n answers.next = {type:\"choice\", choice:\"c100\", confidence:1, probabilities:{c100:1}};\n answers.goal_reached = {type:\"noul\", noul:0};\n }\n return {answers,model:\"fixture\",usage:{input_tokens:0,output_tokens:0}};\n};\nconst decision = await decide(page, \"Find the destination relevant to my task\", [], memory, fake);\ncheck(decision.considered === 60 && !scoredKeys.includes(\"g0\") && scoredKeys.includes(\"g45\"), \"history is filtered before allocating replacement content candidates\");\ncheck(scoredKeys.includes(\"g100\") && scoredKeys.length === 120, \"navigation gets scored without adding model questions beyond the existing budget\");\ncheck(sawRegions && sawGeneralGuidance, \"model receives region context with general goal-based guidance\");\ncheck(decision.target?.region === \"navigation\", \"navigation controls remain executable choices\");\nconsole.log(count + \" candidate checks passed.\");\n",[],[248,221],"ef2f893b-91b4-4555-8a39-33bd924ec60e","budget.ts","2843618e-b222-11f1-9501-1607ee4eb77e",77,["D",1789599519913],"/**\n * Checks the budget guard without spending anything. The only mutation it\n * attempts is a reservation for more than the whole budget, which must be\n * refused — so this is safe to run against the live ledger any time.\n *\n * Run it with `run_file` after touching budget.ts.\n */\nimport {\n BUDGET_USD,\n estimateInputTokens,\n getBudget,\n reconcile,\n reserve,\n USD_PER_INPUT_TOKEN,\n} from \"../budget.ts\";\nimport { QUESTIONS } from \"../questions.ts\";\n\nconst state = await getBudget();\nconsole.log(\n `budget $${BUDGET_USD.toFixed(2)} · spent $${state.spentUsd.toFixed(4)} over ${state.calls} calls · ${state.inputTokens} input tokens`,\n);\n\n// A reservation for more than the entire budget has to be refused. If this\n// ever printed false it would charge the ledger $2*2, so it must be true.\n// `unavailable` would mean the ledger itself couldn't be reached, which is a\n// different answer and not the one being tested here.\nconst huge = await reserve(Math.ceil((BUDGET_USD * 2) / USD_PER_INPUT_TOKEN));\nconsole.log(\n \"over-budget reservation refused:\",\n !huge.ok && !(\"unavailable\" in huge),\n);\n\n// A normal reservation must come back with a ledger to report, and the\n// correction from it must land on the *next* reservation rather than in a\n// write of its own. This spends two calls' worth (~$0.00007), which is the\n// only way to exercise the fold.\n//\n// The assertion is a delta rather than an absolute: this script may itself be\n// the only thing running, but the live demo is also moving the same ledger.\nconst estimate = estimateInputTokens(70, QUESTIONS);\nconst small = await reserve(estimate);\nconsole.log(\n \"normal reservation ok:\",\n small.ok,\n small.ok ? `(ledger now ${small.state.inputTokens} tokens / ${small.state.calls} calls)` : \"\",\n);\nif (small.ok) {\n reconcile(small, estimate + 25); // pretend the call ran 25 tokens over\n const next = await reserve(estimate);\n // The second reservation should carry its own estimate *plus* the 25 the\n // first one overspent. If the correction were dropped, or written twice,\n // this number would be 878 or 1,806 instead.\n const grew = next.ok ? next.state.inputTokens - small.state.inputTokens : NaN;\n const expected = estimate + 25;\n console.log(\n `pending correction folded into next reservation: ${grew === expected} (grew ${grew}, expected ${expected})`,\n );\n}\n\n// The estimate only has to be in the right ballpark — reconcile() corrects the\n// ledger with the real usage right after each call. But if it's low by a lot,\n// concurrent requests get more slack than they should, so keep it close.\nconst questionsJson = JSON.stringify(QUESTIONS).length;\nconsole.log(`questions payload: ${questionsJson} chars`);\nfor (const chars of [0, 500, 4000]) {\n const est = estimateInputTokens(chars, QUESTIONS);\n console.log(\n ` state ${String(chars).padStart(4)} chars → estimate ${String(est).padStart(4)} tokens ($${(est * USD_PER_INPUT_TOKEN).toFixed(6)})`,\n );\n}\n\nconst full = estimateInputTokens(4000, QUESTIONS);\nconsole.log(\n `a full budget is ~${Math.floor(BUDGET_USD / (full * USD_PER_INPUT_TOKEN)).toLocaleString()} max-size calls`,\n);",[],[248,369],"15abf26c-b1b9-45dd-a7cd-d2d7e1a96bca","back-browser.ts","c2523f06-b22d-11f1-ab15-1607ee4eb77e",154,["D",1789604502850],"/**\n * Live Kernel smoke test for Back on fixture pages. Creates one short-lived\n * browser and always deletes it. Makes no model calls.\n */\nimport { createBrowser, destroyBrowser, runPlaywright } from \"../kernel.ts\";\nimport { act, describeAction, perceive } from \"../browser-use.ts\";\nimport { availableCandidates, backOption, observePrevious, pageKey, rememberAttempt } from \"../history.ts\";\nimport type { Decision } from \"../decide.ts\";\n\nfunction check(ok: unknown, message: string) {\n if (!ok) throw new Error(message);\n console.log(\"PASS\", message);\n}\nconst browser = await createBrowser({ name: \"jev-back-regression\", idleTimeoutSec: 60 });\ntry {\n const source = \"data:text/html,\" + encodeURIComponent('Architecture fixture

Architecture

Buildings
Eiffel Tower

');\n const deadEnd = \"data:text/html,\" + encodeURIComponent('Buildings fixture

Buildings

No useful onward route.

');\n const go = async (url: string) => {\n const r = await runPlaywright(browser.session_id, `await page.goto(${JSON.stringify(url)}, { waitUntil: \"domcontentloaded\" }); return true;`);\n if (!r.success) throw new Error(r.error);\n };\n await go(source);\n const parent = await perceive(browser.session_id);\n check(!!parent.navigation, \"perception reads actual Chromium navigation history\");\n const state = await pageKey(parent);\n const buildings = parent.candidates.find((c) => c.label === \"Buildings\");\n check(!!buildings, \"fixture exposes the explored route\");\n const step = rememberAttempt(parent, state, { action: \"click\", target: buildings } as Decision, 'click \"Buildings\"');\n await go(deadEnd);\n const child = await perceive(browser.session_id);\n const childState = await pageKey(child);\n const steps = [step];\n observePrevious(steps, child, childState);\n const recovery = backOption(child, { state: childState, steps });\n check(!!recovery && recovery.alternatives.includes(\"Eiffel Tower\"), \"live dead end offers Back with an untried route\");\n const decision = { action: \"back\", back: recovery } as Decision;\n const backRecord = rememberAttempt(child, childState, decision, describeAction(decision));\n steps.push(backRecord);\n await act(browser.session_id, decision);\n const returned = await perceive(browser.session_id);\n const returnedState = await pageKey(returned);\n observePrevious(steps, returned, returnedState);\n check(returned.navigation?.currentId === parent.navigation?.currentId && returned.url === parent.url, \"Back reaches the verified original browser entry\");\n check(returnedState === state, \"restored page has the same state fingerprint\");\n const remaining = availableCandidates(returned, { state: returnedState, steps });\n check(remaining.some((c) => c.label === \"Eiffel Tower\") && !remaining.some((c) => c.label === \"Buildings\"), \"Back exposes the alternative without repeating Buildings\");\n check(backRecord.outcome === \"changed\", \"successful Back is recorded as a changed observation\");\n\n // A stale decision must be rejected without navigating.\n let rejected = false;\n try { await act(browser.session_id, decision); } catch { rejected = true; }\n check(rejected, \"stale Back destination is rejected\");\n check((await perceive(browser.session_id)).navigation?.currentId === parent.navigation?.currentId, \"rejected Back leaves navigation unchanged\");\n\n // Same-document navigation can return null from Playwright goBack.\n const pushed = await runPlaywright(browser.session_id, 'await page.evaluate(() => history.pushState({}, \"\", \"#another-state\")); return true;');\n if (!pushed.success) throw new Error(pushed.error);\n const sameDocument = await perceive(browser.session_id);\n const sameState = await pageKey(sameDocument);\n const sameBack = backOption(sameDocument, { state: sameState, steps: [step] });\n check(!!sameBack, \"same-document history supports Back\");\n await act(browser.session_id, { action: \"back\", back: sameBack } as Decision);\n check((await perceive(browser.session_id)).navigation?.currentId === parent.navigation?.currentId, \"same-document Back succeeds even without an HTTP response\");\n console.log(\"11 live Back checks passed.\");\n} finally {\n await destroyBrowser(browser.session_id);\n console.log(\"Test browser deleted.\");\n}\n",[],[248,377],["D",1789588833583],[278,279,280,281,282,283,284],[248],"79588ce1-a520-4f24-bd1d-1a35911e5912","root.tsx","01a0abce-8571-76e1-8061-bf005da2f3ad",19,["D",1789589059333],"/** @jsxImportSource npm:hono@4/jsx */\nimport { raw } from \"npm:hono@4/html\";\nimport { immutableFileUrl } from \"https://esm.town/v/std/utils/index.ts\";\n\n/**\n * Inlined before Twind loads, so the first paint isn't unstyled — Twind is\n * fetched from a CDN at runtime. Also holds the keyframes, which Twind's\n * Tailwind v2 theme has no way to express.\n *\n * Dark by design. The thing this page is for is being screen-recorded, and\n * white-on-near-black stays legible at Twitter's compression and at a glance\n * from across a room.\n */\nconst CSS = `\nhtml, body { background: #0b0b0d; color: #fff; }\n@keyframes captionIn {\n from { opacity: 0; transform: translateY(8px); }\n to { opacity: 1; transform: none; }\n}\n.caption-in { animation: captionIn 260ms ease-out; }\n@keyframes breathe {\n 0%, 100% { opacity: 1; }\n 50% { opacity: 0.3; }\n}\n.breathe { animation: breathe 1.1s ease-in-out infinite; }\n`;\n\n// The HTML shell for the app. It is never cached, so immutableFileUrl can stamp\n// the current val version into each asset URL — the browser caches those\n// immutably, and publishing the val changes the URLs, refetching exactly once.\nexport function Root() {\n return (\n <>\n {raw(\"\")}\n \n \n \n \n Jev Browser Use\n \n \n \n \n \n \n \n \n

Diff · v204