fix(app): hide cached panel divider

fix(codemode): add Promise.try and surface a failing iterator close on generator return (#50419 )
refactor(tui): favor dark theme base (#50412 )
2026-09-22 00:27:41 +00:00 · 2026-09-21 23:02:42 +00:00 · 2026-09-21 15:35:11 -05:00 · 2026-09-21 16:23:38 -04:00 · 2026-09-21 14:45:33 -05:00 · 2026-09-21 14:35:46 -05:00
215 changed files with 5804 additions and 1626 deletions
@@ -32,7 +32,7 @@
    },
    "packages/ai": {
      "name": "@opencode/ai",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@aws-sdk/credential-providers": "3.1057.0",
        "@opencode/schema": "workspace:*",
@@ -54,7 +54,7 @@
    },
    "packages/app": {
      "name": "@opencode/app",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@corvu/drawer": "catalog:",
        "@dnd-kit/abstract": "0.5.0",
@@ -111,7 +111,7 @@
    },
    "packages/cli": {
      "name": "@opencode/cli",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "bin": {
        "opencode2": "./bin/opencode2.cjs",
      },
@@ -175,7 +175,7 @@
    },
    "packages/client": {
      "name": "@opencode/client",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/protocol": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -201,7 +201,7 @@
    },
    "packages/codemode": {
      "name": "@opencode/codemode",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "acorn": "8.15.0",
        "effect": "catalog:",
@@ -214,7 +214,7 @@
    },
    "packages/console/app": {
      "name": "@opencode/console-app",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@ibm/plex": "6.4.1",
@@ -250,7 +250,7 @@
    },
    "packages/console/core": {
      "name": "@opencode/console-core",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@aws-sdk/client-sts": "3.782.0",
        "@jsx-email/render": "1.1.1",
@@ -277,7 +277,7 @@
    },
    "packages/console/function": {
      "name": "@opencode/console-function",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@openauthjs/openauth": "0.0.0-20250322224806",
        "@opencode/console-core": "workspace:*",
@@ -294,7 +294,7 @@
    },
    "packages/console/mail": {
      "name": "@opencode/console-mail",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@jsx-email/all": "2.2.3",
        "@jsx-email/cli": "1.4.3",
@@ -318,7 +318,7 @@
    },
    "packages/console/support": {
      "name": "@opencode/console-support",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@opencode/console-core": "workspace:*",
@@ -338,7 +338,7 @@
    },
    "packages/core": {
      "name": "@opencode/core",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@ai-sdk/cohere": "3.0.27",
        "@ai-sdk/gateway": "3.0.104",
@@ -406,10 +406,10 @@
    },
    "packages/desktop": {
      "name": "@opencode/desktop",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@zip.js/zip.js": "2.7.62",
-        "electron-context-menu": "4.1.2",
+        "electron-context-menu": "5.0.0",
        "electron-log": "^5",
        "electron-updater": "6.8.9",
        "lighthouse": "13.4.1",
@@ -436,7 +436,7 @@
        "drizzle-kit": "catalog:",
        "drizzle-orm": "catalog:",
        "effect": "catalog:",
-        "electron": "42.10.1",
+        "electron": "44.4.3",
        "electron-builder": "26.15.7",
        "electron-vite": "6.0.0-beta.1",
        "puppeteer-core": "25.9.0",
@@ -455,7 +455,7 @@
    },
    "packages/enterprise": {
      "name": "@opencode/enterprise",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@hono/standard-validator": "catalog:",
        "@opencode-ai/sdk": "1.18.21",
@@ -492,7 +492,7 @@
    },
    "packages/function": {
      "name": "@opencode/function",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@octokit/auth-app": "8.0.1",
        "@octokit/rest": "catalog:",
@@ -508,7 +508,7 @@
    },
    "packages/http-recorder": {
      "name": "@opencode/http-recorder",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@effect/platform-node-shared": "4.0.0-rc.112",
      },
@@ -527,7 +527,7 @@
    },
    "packages/httpapi-codegen": {
      "name": "@opencode/httpapi-codegen",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "effect": "catalog:",
        "prettier": "3.6.2",
@@ -540,7 +540,7 @@
    },
    "packages/latex": {
      "name": "@opencode/latex",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -554,7 +554,7 @@
    },
    "packages/merman": {
      "name": "@opencode/merman",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -569,7 +569,7 @@
    },
    "packages/plugin": {
      "name": "@opencode/plugin",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@ai-sdk/provider": "3.0.8",
        "@opencode/ai": "workspace:*",
@@ -608,7 +608,7 @@
    },
    "packages/plugin-browser": {
      "name": "@opencode/plugin-browser",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -638,7 +638,7 @@
    },
    "packages/protocol": {
      "name": "@opencode/protocol",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/schema": "workspace:*",
        "effect": "catalog:",
@@ -653,7 +653,7 @@
    },
    "packages/schema": {
      "name": "@opencode/schema",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@standard-schema/spec": "catalog:",
        "effect": "catalog:",
@@ -677,7 +677,7 @@
    },
    "packages/sdk": {
      "name": "@opencode/sdk",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -698,7 +698,7 @@
    },
    "packages/server": {
      "name": "@opencode/server",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@effect/platform-node": "catalog:",
        "@effect/platform-node-shared": "catalog:",
@@ -720,7 +720,7 @@
    },
    "packages/session-ui": {
      "name": "@opencode/session-ui",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode/client": "workspace:*",
@@ -755,7 +755,7 @@
    },
    "packages/simulation": {
      "name": "@opencode/simulation",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/ai": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -775,7 +775,7 @@
    },
    "packages/stats/app": {
      "name": "@opencode/stats-app",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@ibm/plex": "6.4.1",
        "@kobalte/core": "catalog:",
@@ -809,7 +809,7 @@
    },
    "packages/stats/core": {
      "name": "@opencode/stats-core",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@aws-sdk/client-athena": "3.933.0",
        "@planetscale/database": "1.19.0",
@@ -828,7 +828,7 @@
    },
    "packages/stats/server": {
      "name": "@opencode/stats-server",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@aws-sdk/client-firehose": "3.933.0",
        "@effect/platform-node": "catalog:",
@@ -874,7 +874,7 @@
    },
    "packages/theme": {
      "name": "@opencode/theme",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opentui/core": "catalog:",
        "effect": "catalog:",
@@ -888,7 +888,7 @@
    },
    "packages/tui": {
      "name": "@opencode/tui",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -923,7 +923,7 @@
    },
    "packages/ui": {
      "name": "@opencode/ui",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@pierre/diffs": "catalog:",
@@ -958,7 +958,7 @@
    },
    "packages/util": {
      "name": "@opencode/util",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@effect/opentelemetry": "catalog:",
        "@effect/platform-node": "catalog:",
@@ -991,7 +991,7 @@
    },
    "packages/web": {
      "name": "@opencode/web",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@astrojs/cloudflare": "12.6.3",
        "@astrojs/markdown-remark": "6.3.1",
@@ -1032,7 +1032,7 @@
    },
    "services/update": {
      "name": "@opencode/update",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "jose": "6.0.11",
        "semver": "catalog:",
@@ -3880,13 +3880,13 @@

    "ejs": ["ejs@3.1.10", "", { "dependencies": { "jake": "^10.8.5" }, "bin": { "ejs": "bin/cli.js" } }, "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA=="],

-    "electron": ["electron@42.10.1", "", { "dependencies": { "@electron-internal/extract-zip": "^1.0.1", "@electron/get": "^5.0.0", "@types/node": "^24.9.0" }, "bin": { "electron": "cli.js", "install-electron": "install.js" } }, "sha512-ITc1HPeoDzsxCCaH6MFsN67Nq2nUiJf5N9pBWxzhUpFfKJF0IwiAkKT3emg1lPbvC4OfFE+Cdwe4vhgdOZ1YKg=="],
+    "electron": ["electron@44.4.3", "", { "dependencies": { "@electron-internal/extract-zip": "^1.0.1", "@electron/get": "^5.0.0", "@types/node": "^24.9.0" }, "bin": { "electron": "cli.js", "install-electron": "install.js" } }, "sha512-LTpSFTB40qVCXIX5xMo+cgHI/Jjkbjw7VpB26PccEbroqOn72LBukeaDwPVo1fBYzSzs0c9iPuAucFCO7Tw81Q=="],

    "electron-builder": ["electron-builder@26.15.7", "", { "dependencies": { "app-builder-lib": "26.15.7", "builder-util": "26.15.3", "builder-util-runtime": "9.7.0", "chalk": "^4.1.2", "ci-info": "^4.2.0", "dmg-builder": "26.15.7", "fs-extra": "^10.1.0", "lazy-val": "^1.0.5", "simple-update-notifier": "2.0.0", "yargs": "^17.6.2" }, "bin": { "electron-builder": "./cli.js", "install-app-deps": "./install-app-deps.js" } }, "sha512-DBpaNzxsPs1BvEblzFoNriSbzsBqDCy/gseIngeEhYzQG1IxfB7Hvc2tBBVmpWE2BTQGP9J1RrAvDT+Vc/uAxg=="],

    "electron-builder-squirrel-windows": ["electron-builder-squirrel-windows@26.15.7", "", { "dependencies": { "app-builder-lib": "26.15.7", "builder-util": "26.15.3", "electron-winstaller": "5.4.0" } }, "sha512-B4uvn2NzFSuf084udWqugludFull6CRJiWe2dLzMnZLl6G5hdAGk0fsBMGlBSpKjvQCJn8IPc+S7OnJ+GXqwLA=="],

-    "electron-context-menu": ["electron-context-menu@4.1.2", "", { "dependencies": { "cli-truncate": "^4.0.0", "electron-dl": "^4.0.0", "electron-is-dev": "^3.0.1" } }, "sha512-9xYTUV0oRqKL50N9W71IrXNdVRB0LuBp3R1zkUdUc2wfIa2/QZwYYj5RLuO7Tn7ZSLVIaO3X6u+EIBK+cBvzrQ=="],
+    "electron-context-menu": ["electron-context-menu@5.0.0", "", { "dependencies": { "cli-truncate": "^4.0.0", "electron-dl": "^4.0.0", "electron-is-dev": "^3.0.1" } }, "sha512-rgFpRtwY0/rhsRCoz9rE6VM4WueEsLbIpca7ucOhERVrbGB2dQrxa9xwBNLplU54jRgPuv6nTEbxoplE5bzy2A=="],

    "electron-dl": ["electron-dl@4.0.0", "", { "dependencies": { "ext-name": "^5.0.0", "pupa": "^3.1.0", "unused-filename": "^4.0.1" } }, "sha512-USiB9816d2JzKv0LiSbreRfTg5lDk3lWh0vlx/gugCO92ZIJkHVH0UM18EHvKeadErP6Xn4yiTphWzYfbA2Ong=="],

@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-8mOzCscBAuogG4tm8CroqjTX5E5yzCvTobbhKvxQP0U=",
-    "aarch64-linux": "sha256-drrRSpzxC8bfaTXBpOyaN0QAyBVV7WJzm0NstJ+8sAE=",
-    "aarch64-darwin": "sha256-YY5A/zxLPONvgnI+DZlzcD2K5Q9PIw4F2YbDxKbT4UU=",
-    "x86_64-darwin": "sha256-/c/Ew4onA+9+l6GRKXz3zWq3QFESM7j5RyGLCWRPQFw="
+    "x86_64-linux": "sha256-/jah4P2a0aGJNJ0aMdlFEbGHAXx33lqxHbc7UmpLFDg=",
+    "aarch64-linux": "sha256-L3SoZ24qNXicsE2FK6LATQjOmjPxY679RjugrUyO/1Y=",
+    "aarch64-darwin": "sha256-pI9NT8KWUPi+JCk6DYMqIAYmBqTbi13uL4VdNV3WS6Y=",
+    "x86_64-darwin": "sha256-rMAGhTTz46KA5Ya7E5J0af7Bn1QzTDhTaNfNJm8qfsw="
  }
 }
@@ -2,7 +2,7 @@
  "$schema": "https://json.schemastore.org/package.json",
  "name": "opencode",
  "description": "AI-powered development tool",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "private": true,
  "type": "module",
  "packageManager": "bun@1.4.2",
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "name": "@opencode/ai",
  "type": "module",
  "license": "MIT",
@@ -19,6 +19,13 @@ export function mountBrowserPane() {
      session: "Alpha",
      mounted: true,
      visible: true,
+      url: undefined as string | undefined,
+      loading: false,
+      generation: 0,
+      delayNavigation: false,
+      pendingURL: undefined as string | undefined,
+      loadErrors: {} as Record<string, string | undefined>,
+      error: undefined as string | undefined,
      layouts: {} as Record<string, BrowserPaneLayout | undefined>,
    })
    const tabs = ["Alpha", "Beta"].map((name) => ({
@@ -47,13 +54,33 @@ export function mountBrowserPane() {
      opened: () => !!registrations.get(store.session),
      state: () => ({ tabs: tabs.filter((tab) => tab.title === store.session), focusedTabID: null }),
      tabs: () => tabs.filter((tab) => tab.title === store.session),
-      active: () => tabs.find((tab) => tab.title === store.session) ?? tabs[0],
+      active: () => {
+        const tab = tabs.find((tab) => tab.title === store.session) ?? tabs[0]
+        return {
+          ...tab,
+          url: store.url ?? tab.url,
+          loading: store.loading,
+          generation: store.generation,
+          loadError: store.loadErrors[store.session],
+        }
+      },
      registration: () => registrations.get(store.session),
-      error: () => undefined,
+      error: () => store.error ?? (store.loadErrors[store.session] ? "Request failed" : undefined),
      suspended: () => false,
      close: () => undefined,
      open: () => undefined,
-      command: () => undefined,
+      command: (command) => {
+        setStore("error", undefined)
+        if (command.type === "navigate" || command.type === "reload") setStore("loadErrors", store.session, undefined)
+        if (command.type === "navigate") {
+          if (store.delayNavigation) {
+            setStore("pendingURL", command.url)
+            return
+          }
+          setStore({ url: command.url, loading: false, generation: store.generation + 1 })
+        }
+        if (command.type === "stop") setStore("loading", false)
+      },
    }
    return (
      <>
@@ -64,6 +91,32 @@ export function mountBrowserPane() {
            {(name) => <button onClick={() => setStore({ session: name, mounted: name !== "Empty" })}>{name}</button>}
          </For>
          <button onClick={() => setStore("mounted", false)}>Unmount pane</button>
+          <button onClick={() => setStore({ url: "about:blank", loading: false })}>Blank page</button>
+          <button onClick={() => setStore({ url: "about:blank", loading: true })}>Loading page</button>
+          <button
+            onClick={() =>
+              setStore({ loading: true, generation: store.generation + 1, loadErrors: { [store.session]: undefined } })
+            }
+          >
+            Load current page
+          </button>
+          <button onClick={() => setStore("loadErrors", store.session, "ERR_CONNECTION_REFUSED")}>Failed page</button>
+          <button onClick={() => setStore("delayNavigation", true)}>Delay navigation</button>
+          <button onClick={() => setStore({ error: "ERR_BLOCKED_BY_CLIENT", pendingURL: undefined })}>
+            Block navigation
+          </button>
+          <button
+            onClick={() =>
+              setStore({
+                url: store.pendingURL,
+                pendingURL: undefined,
+                loading: false,
+                generation: store.generation + 1,
+              })
+            }
+          >
+            Complete navigation
+          </button>
          <button onClick={() => setStore("visible", (visible) => !visible)}>Toggle Review tab</button>
        </nav>
        <div style={{ width: "640px", height: "360px", border: "1px solid #555" }}>
@@ -57,3 +57,153 @@ story("hides the native view immediately while the pane stays mounted", async ({
  await toggle.click()
  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
 })
+
+story("shows the empty state over a blank native page and restores navigation", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Blank page", exact: true }).click()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await expect(root.getByText('Or prompt "Open in the app browser"', { exact: true })).toBeVisible()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeDisabled()
+
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://example.com/")
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeEnabled()
+})
+
+story("keeps Stop available and hides the empty state while a blank page loads", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Loading page", exact: true }).click()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+  await root.getByRole("button", { name: "Stop", exact: true }).click()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+})
+
+story("keeps the submitted URL visible until the browser reports navigation", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Blank page", exact: true }).click()
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://example.com/")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(address).toHaveValue("https://example.com/")
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+
+  await root.getByRole("button", { name: "Complete navigation", exact: true }).click()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(address).toHaveValue("https://example.com/")
+
+  await address.fill("https://unsubmitted.example/")
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  await expect(address).toHaveValue("https://example.com/")
+})
+
+story("restores the current URL when a submitted navigation is blocked", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://blocked.example/")
+  await address.press("Enter")
+  await expect(address).toHaveValue("https://blocked.example/")
+  await root.getByRole("button", { name: "Block navigation", exact: true }).click()
+  await expect(root.getByText("ERR_BLOCKED_BY_CLIENT", { exact: true })).toBeVisible()
+  await expect(address).toHaveValue("https://alpha.example/")
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+})
+
+story("shows a themed failure state for only the failed tab and allows retry", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Failed page", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeVisible()
+  await expect(root.getByText("Check the URL and your connection, then try again.", { exact: true })).toBeVisible()
+  await expect(root.getByText("Request failed", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+  await expect(root.getByRole("textbox", { name: "Browser address", exact: true })).toHaveValue(
+    "https://alpha.example/",
+  )
+
+  await root.getByRole("button", { name: "Beta", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Beta")).toHaveAttribute("data-visible", "true")
+  await root.getByRole("button", { name: "Alpha", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeVisible()
+
+  await root.getByRole("button", { name: "Reload", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+})
+
+story("returns a failed tab to the empty state when an empty URL is submitted", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Failed page", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeVisible()
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(address).toHaveValue("")
+  await root.getByRole("button", { name: "Load current page", exact: true }).click()
+  await expect(root.getByRole("button", { name: "Stop", exact: true })).toBeEnabled()
+  await root.getByRole("button", { name: "Complete navigation", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeHidden()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeDisabled()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+})
+
+story("selects the full URL when the address field gains focus", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.click()
+  await expect(address).toHaveJSProperty("selectionStart", 0)
+  await expect(address).toHaveJSProperty("selectionEnd", "https://alpha.example/".length)
+  await address.pressSequentially("https://example.com/")
+  await expect(address).toHaveValue("https://example.com/")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await address.focus()
+  await expect(address).toHaveJSProperty("selectionStart", 0)
+  await expect(address).toHaveJSProperty("selectionEnd", "https://example.com/".length)
+  await address.press("ArrowRight")
+  await address.click()
+  await expect(address).toHaveJSProperty("selectionStart", 0)
+  await expect(address).toHaveJSProperty("selectionEnd", "https://example.com/".length)
+})
+
+story("keeps the current page visible while a submitted URL loads", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://example.com/")
+  await address.press("Enter")
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(address).toHaveValue("https://example.com/")
+
+  await root.getByRole("button", { name: "Load current page", exact: true }).click()
+  await expect(root.getByRole("button", { name: "Stop", exact: true })).toBeEnabled()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await root.getByRole("button", { name: "Complete navigation", exact: true }).click()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(address).toHaveValue("https://example.com/")
+})
+
+story("keeps the current page and restores its URL when an empty address is submitted", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(address).toHaveValue("https://alpha.example/")
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeEnabled()
+})
@@ -17,14 +17,12 @@ const milestones = [
  "electronSpawnStarted",
  "debugEndpointReady",
  "electronStarted",
+  "layersReady",
+  "windowVisible",
  "serviceEnsureStarted",
  "serviceSpawnRequested",
  "serviceReady",
-  "backgroundLoadingReady",
  "rendererViteConnected",
-  "rendererInitializationStarted",
-  "rendererInitializationReady",
-  "windowVisible",
  "homeReady",
 ] as const
 const phases = [
@@ -128,14 +126,12 @@ const milestonePatterns: ReadonlyArray<{ name: Milestone; text: string }> = [
  { name: "electronSpawnStarted", text: "starting electron app..." },
  { name: "debugEndpointReady", text: "DevTools listening on ws://" },
  { name: "electronStarted", text: "app starting" },
+  { name: "layersReady", text: "layers ready" },
+  { name: "windowVisible", text: "main window visible" },
  { name: "serviceEnsureStarted", text: "starting v2 background service" },
  { name: "serviceSpawnRequested", text: "v2 CLI background service starting" },
  { name: "serviceReady", text: "v2 CLI background service ready" },
-  { name: "backgroundLoadingReady", text: "loading task finished" },
  { name: "rendererViteConnected", text: "[vite] connected." },
-  { name: "rendererInitializationStarted", text: "awaiting server ready" },
-  { name: "rendererInitializationReady", text: "server ready" },
-  { name: "windowVisible", text: "main window visible" },
 ]

 async function createColdProfile() {
@@ -404,14 +400,12 @@ function requireMilestones(observed: Partial<Record<Milestone, number>>) {
    electronSpawnStarted: get("electronSpawnStarted"),
    debugEndpointReady: get("debugEndpointReady"),
    electronStarted: get("electronStarted"),
+    layersReady: get("layersReady"),
+    windowVisible: get("windowVisible"),
    serviceEnsureStarted: get("serviceEnsureStarted"),
    serviceSpawnRequested: get("serviceSpawnRequested"),
    serviceReady: get("serviceReady"),
-    backgroundLoadingReady: get("backgroundLoadingReady"),
    rendererViteConnected: get("rendererViteConnected"),
-    rendererInitializationStarted: get("rendererInitializationStarted"),
-    rendererInitializationReady: get("rendererInitializationReady"),
-    windowVisible: get("windowVisible"),
    homeReady: get("homeReady"),
  }
 }
@@ -20,14 +20,12 @@ describe("desktop startup benchmark", () => {
      ["electronSpawnStarted", "starting electron app..."],
      ["debugEndpointReady", "DevTools listening on ws://"],
      ["electronStarted", "app starting"],
+      ["layersReady", "layers ready"],
+      ["windowVisible", "main window visible"],
      ["serviceEnsureStarted", "starting v2 background service"],
      ["serviceSpawnRequested", "v2 CLI background service starting"],
      ["serviceReady", "v2 CLI background service ready"],
-      ["backgroundLoadingReady", "loading task finished"],
      ["rendererViteConnected", "[vite] connected."],
-      ["rendererInitializationStarted", "awaiting server ready"],
-      ["rendererInitializationReady", "server ready"],
-      ["windowVisible", "main window visible"],
    ] as const
    cases.forEach(([milestone, line]) => {
      expect(milestoneForLine(`\u001b[32m${line}\u001b[39m`)).toBe(milestone)
@@ -58,14 +56,12 @@ function sample(run: number, commandToHomeReadyMs: number): DesktopStartupSample
    electronSpawnStarted: 7,
    debugEndpointReady: 8,
    electronStarted: 9,
-    serviceEnsureStarted: 10,
-    serviceSpawnRequested: 11,
-    serviceReady: 12,
-    backgroundLoadingReady: 13,
-    rendererViteConnected: 14,
-    rendererInitializationStarted: 15,
-    rendererInitializationReady: 16,
-    windowVisible: 17,
+    layersReady: 10,
+    windowVisible: 11,
+    serviceEnsureStarted: 12,
+    serviceSpawnRequested: 13,
+    serviceReady: 14,
+    rendererViteConnected: 15,
    homeReady: commandToHomeReadyMs,
  }
  return {
@@ -80,8 +76,8 @@ function sample(run: number, commandToHomeReadyMs: number): DesktopStartupSample
      electronStartup: 2,
      serviceSpawnWait: 1,
      serviceProcessStartup: 1,
-      rendererStartup: commandToHomeReadyMs - 14,
-      visibleWindowToHome: commandToHomeReadyMs - 17,
+      rendererStartup: commandToHomeReadyMs - 15,
+      visibleWindowToHome: commandToHomeReadyMs - 11,
    },
    service: { version: "2.0.0-local-test", url: "http://127.0.0.1:3000", pid: run },
  }
@@ -71,7 +71,7 @@ for (const direction of ["ltr", "rtl"] as const) {
    const shifted = await content.evaluate((element) => getComputedStyle(element).translate)
    await content.evaluate((element) => element.setAttribute("data-summary-motion", ""))
    // Keep issuing resize events before the idle timer expires, including crossing the width cutoff.
-    for (const width of [1520, 1280, 1600]) {
+    for (const width of [1520, 1280, 1800]) {
      await page.setViewportSize({ width, height: 900 })
      await expect(panel).toHaveAttribute("data-summary-resizing", "true")
      await page.clock.runFor(100)
@@ -84,6 +84,7 @@ for (const direction of ["ltr", "rtl"] as const) {
    await expect(content).toHaveAttribute("data-summary-motion", "transitionrun,transitionend,")
    await expect(content).not.toHaveCSS("translate", shifted)
    await page.setViewportSize({ width: 1440, height: 900 })
+    await expect(panel).toHaveAttribute("data-summary-resizing", "false")
    await expect(content).toHaveCSS("translate", shifted)

    await content.evaluate((element) => element.setAttribute("data-summary-motion", ""))
@@ -112,7 +113,8 @@ for (const direction of ["ltr", "rtl"] as const) {
    await expect(summary).toBeVisible()

    await page.setViewportSize({ width: 1800, height: 900 })
-    await expect(content).toHaveCSS("translate", "0px")
+    await expect(panel).toHaveAttribute("data-summary-resizing", "false")
+    await expect(content).toHaveCSS("translate", "none")
    await expect(summary).toBeVisible()

    await page.emulateMedia({ reducedMotion: "reduce" })
@@ -116,7 +116,7 @@ test("single-server settings expose scoped pages without a server picker", async
  await expect(connection.getByRole("heading", { name: "Connection", exact: true })).toBeVisible()
  await expect(connection.locator('[data-component="settings-list"]')).toHaveCSS("padding-left", "16px")
  await expect(connection.locator(".settings-servers-row")).toHaveCSS("padding-top", "20px")
-  await expect(connection.locator(".settings-servers-lead")).toHaveCSS("column-gap", "4px")
+  await expect(connection.locator(".settings-servers-lead")).toHaveCSS("column-gap", "10px")
  await expect(connection.locator(".settings-servers-copy")).toHaveCSS("row-gap", "6px")
  await expect(settings.getByRole("heading", { name: "Preferences", exact: true })).toBeVisible()
  await expect(settings.getByText("Terminal shell", { exact: true })).toBeVisible()
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/app",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "description": "",
  "type": "module",
  "exports": {
@@ -65,14 +65,14 @@
  }

  /* Keep the 1000px conversation intact, with 320px for the summary and its gutters.
-     Move only as far as needed; wider panels already have enough space in the margin. */
-  @container session-chat (min-width: 1320px) {
+     When they overlap, center the conversation in the space that remains beside the summary. */
+  @container session-chat (min-width: 1320px) and (width < 1640px) {
    [data-slot="session-chat-panel"][data-summary-open="true"]
      :is([data-timeline-virtual-content], [data-component="session-composer-dock"] > div) {
-      --session-summary-translate: min(0px, calc(50cqi - 820px));
+      --session-summary-translate: -160px;

      &:dir(rtl) {
-        --session-summary-translate: max(0px, calc(820px - 50cqi));
+        --session-summary-translate: 160px;
      }
    }
  }
@@ -155,7 +155,7 @@
  }

  [data-slot="session-side-region-presence"][data-opened="false"] {
-    animation: side-region-presence-out 240ms cubic-bezier(0.22, 1, 0.36, 1);
+    animation: side-region-presence-out 240ms cubic-bezier(0.22, 1, 0.36, 1) forwards;
  }

  [data-slot="terminal-panel-presence"][data-opened="true"] {
@@ -625,6 +625,16 @@ export const dict = {
  "toast.file.loadFailed.title": "Failed to load file",
  "file.error.notFound": "File not found: {{name}}",
  "toast.file.listFailed.title": "Failed to list files",
+  "file.view.preview": "Preview",
+  "file.view.source": "Source",
+  "file.view.openInBrowser": "Open in browser",
+  "file.view.binary": "Binary file · {{size}}",
+  "file.view.table.rows.one": "{{count}} row",
+  "file.view.table.rows.other": "{{count}} rows",
+  "file.view.table.columns.one": "{{count}} column",
+  "file.view.table.columns.other": "{{count}} columns",
+  "file.view.table.truncated": "Showing the first {{shown}} of {{total}} rows.",
+  "file.view.fontSample": "Sphinx of black quartz, judge my vow.",

  "toast.context.noLineSelection.title": "No line selection",
  "toast.context.noLineSelection.description": "Select a line range in a file tab first.",
@@ -906,6 +916,10 @@ export const dict = {
  "session.browser.replaced": "Browser control moved to another desktop window.",
  "session.browser.suspended": "Browser suspended. Interact with this session to reconnect.",
  "session.browser.address.placeholder": "Enter URL",
+  "session.browser.empty.title": "Enter URL",
+  "session.browser.empty.description": 'Or prompt "Open in the app browser"',
+  "session.browser.failed.title": "URL can't be reached",
+  "session.browser.failed.description": "Check the URL and your connection, then try again.",

  "titlebar.update": "Update",
  "titlebar.tabs": "Tabs",
@@ -19,6 +19,7 @@ export type BrowserPaneCommand = Browser.Action
 export type BrowserPaneState = Browser.State | null
 export type BrowserPaneEvent =
  | { type: "focus"; tabID: Browser.TabID }
+  | { type: "preview"; path: string }
  | { type: "state"; state: BrowserPaneState; error?: string }

 export type BrowserPaneRegistration = {
@@ -33,6 +33,8 @@ export type FileContent = {
  }
  encoding?: "base64"
  mimeType?: string
+  /** On-disk size when the bytes themselves are not retained. */
+  size?: number
 }

 export type Path = {
@@ -1,14 +1,15 @@
-import { createEffect, createMemo, getOwner, on, onCleanup, runWithOwner } from "solid-js"
+import { batch, createEffect, createMemo, createRoot, getOwner, on, onCleanup, runWithOwner } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
 import { createSimpleContext } from "@opencode/ui/context"
-import type { Browser } from "@opencode/plugin-browser/rpc"
 import { useLanguage } from "@/runtime/i18n/language"
 import type { BrowserPaneCommand } from "@/runtime/platform/browser-pane"
 import { usePlatform } from "@/runtime/platform/platform"
 import type { useServer } from "@/runtime/server/current"
+import type { SessionStateKey } from "@/runtime/server/scope"
 import { useSettings } from "@/settings/model"
 import { findSessionTab, tabKey, useTabs } from "@/shell/tabs/tabs"
-import { useCurrentRoute } from "@/shell/state/layout"
+import { useCurrentRoute, useLayout } from "@/shell/state/layout"
+import { sessionBrowserTab } from "@/shell/state/session-tabs"
 import { createEventListener } from "@solid-primitives/event-listener"
 import { createBrowserConnection, type BrowserConnectionState } from "./connection"

@@ -35,13 +36,14 @@ export const { use: useBrowserAttachments, provider: BrowserAttachmentsProvider
    const settings = useSettings()
    const language = useLanguage()
    const shellTabs = useTabs()
+    const layout = useLayout()
    const route = useCurrentRoute()
    const owner = getOwner()
    const [store, setStore] = createStore<Record<string, BrowserAttachment | undefined>>({})
    // Servers whose plugin lacks the browser RPC; sessions on them stop retrying.
    const [unsupported, setUnsupported] = createStore<Record<string, true | undefined>>({})
    const live = new Map<string, Live>()
-    const focus = new Map<string, Set<(tabID: Browser.TabID) => void>>()
+    const preview = new Map<string, Set<(path: string) => void>>()
    const key = (server: Server, sessionID: string) => `${server.key}\n${sessionID}`
    const enabled = createMemo(
      () => !!platform.browserPane && settings.ready() && settings.general.experimentalBrowser(),
@@ -87,11 +89,14 @@ export const { use: useBrowserAttachments, provider: BrowserAttachmentsProvider
      enabled,
      supported: (server: Server) => !unsupported[server.key],
      state: (server: Server, sessionID: string) => store[key(server, sessionID)],
-      attach(server: Server, sessionID: string) {
+      attach(server: Server, sessionID: string, sessionKey: SessionStateKey) {
        const id = key(server, sessionID)
        if (live.has(id)) return
        const pane = platform.browserPane
        if (!pane || !enabled() || unsupported[server.key] || server.health?.incompatible) return
+        // Focus requests write to the owning session's layout even while another shell tab is routed,
+        // so the Review pane and browser tab are already selected when the user returns to it.
+        const tabs = createRoot((dispose) => ({ dispose, layout: layout.tabs(sessionKey) }), owner)
        const connection = createBrowserConnection({
          pane,
          // Resolve the current port at every wake, including after sidecar replacement.
@@ -100,7 +105,15 @@ export const { use: useBrowserAttachments, provider: BrowserAttachmentsProvider
            sessionID,
            endpoint: { ...server.conn.http, url: server.ctx.sdk.url },
          }),
-          focus: (tabID) => focus.get(id)?.forEach((listener) => listener(tabID)),
+          focus: (tabID) => {
+            const tab = sessionBrowserTab(tabID)
+            batch(() => {
+              shellTabs.setPane(findSessionTab(shellTabs.store, server.key, sessionID), "review", true)
+              if (!tabs.layout.all().includes(tab)) tabs.layout.setAll([...tabs.layout.all(), tab])
+              tabs.layout.setActive(tab)
+            })
+          },
+          preview: (path) => preview.get(id)?.forEach((listener) => listener(path)),
          change: (state) => {
            if (state.error === "browser.pane.unsupported") {
              setUnsupported(server.key, true)
@@ -138,17 +151,18 @@ export const { use: useBrowserAttachments, provider: BrowserAttachmentsProvider
        entry.dispose = () => {
          unsubscribe?.forEach((dispose) => dispose())
          connection.dispose()
+          tabs.dispose()
        }
      },
-      /** Desktop focus requests for a mounted session route; nothing is replayed to routes mounted later. */
-      onFocus(server: Server, sessionID: string, listener: (tabID: Browser.TabID) => void) {
+      /** Agent requests to show a file in this session's Review pane. */
+      onPreview(server: Server, sessionID: string, listener: (path: string) => void) {
        const id = key(server, sessionID)
-        const listeners = focus.get(id) ?? new Set()
+        const listeners = preview.get(id) ?? new Set()
        listeners.add(listener)
-        focus.set(id, listeners)
+        preview.set(id, listeners)
        return () => {
          listeners.delete(listener)
-          if (!listeners.size) focus.delete(id)
+          if (!listeners.size) preview.delete(id)
        }
      },
      command(server: Server, sessionID: string, command: BrowserPaneCommand) {
@@ -28,10 +28,12 @@ function fixture() {
    commands: Browser.Action[]
  }[] = []
  const endpoint = { url: "http://localhost:4096" }
+  const previews: string[] = []
  const connection = createBrowserConnection({
    target: () => ({ serverKey: "browser-test", sessionID: "ses_browser", endpoint: { ...endpoint } }),
    change: (state) => states.push(state),
    focus: () => {},
+    preview: (path) => previews.push(path),
    pane: {
      register(target, emit) {
        const call = { target, emit, closed: false, commands: [] as Browser.Action[] }
@@ -50,9 +52,21 @@ function fixture() {
  })
  connection.wake()
  calls[0].emit({ type: "state", state: browser })
-  return { connection, calls, states, endpoint }
+  return { connection, calls, states, endpoint, previews }
 }

+test("preview requests reach the session without touching connection state", () => {
+  const app = fixture()
+  try {
+    const before = app.states.length
+    app.calls[0].emit({ type: "preview", path: "docs/report.pdf" })
+    expect(app.previews).toEqual(["docs/report.pdf"])
+    expect(app.states).toHaveLength(before)
+  } finally {
+    app.connection.dispose()
+  }
+})
+
 test("suspension retains tabs and reconnects once on demand using the current endpoint", async () => {
  const app = fixture()
  try {
@@ -19,6 +19,7 @@ export function createBrowserConnection(input: {
  target: () => BrowserPaneTarget
  change: (state: BrowserConnectionState) => void
  focus: (tabID: Browser.TabID) => void
+  preview: (path: string) => void
 }) {
  const state: BrowserConnectionState = { browser: null, suspended: false }
  let disposed = false
@@ -33,6 +34,7 @@ export function createBrowserConnection(input: {
      (event) => {
        if (disposed || state.registration !== registration) return
        if (event.type === "focus") return input.focus(event.tabID)
+        if (event.type === "preview") return input.preview(event.path)
        if (event.error === "browser.pane.unsupported" || event.error === "browser.pane.replaced") {
          blocked = true
          registration.close()
@@ -1,4 +1,4 @@
-import { batch, createEffect, createMemo, on, onCleanup } from "solid-js"
+import { batch, createEffect, createMemo, on } from "solid-js"
 import type { Browser } from "@opencode/plugin-browser/rpc"
 import { createStore } from "solid-js/store"
 import { useLanguage } from "@/runtime/i18n/language"
@@ -33,13 +33,6 @@ export function createSessionBrowser(session: SessionModel) {
      attachment()?.browser?.tabs.filter((tab) => session.layout.tabs().all().includes(sessionBrowserTab(tab.id))) ??
      [],
  )
-  const focus = (tabID: Browser.TabID) => {
-    session.layout.view().reviewPanel.open()
-    const tabs = session.layout.tabs()
-    const key = sessionBrowserTab(tabID)
-    if (!tabs.all().includes(key)) tabs.setAll([...tabs.all(), key])
-    tabs.setActive(key)
-  }
  const command = (command: BrowserPaneCommand) => {
    const sessionID = session.identity.sessionID()
    if (!sessionID) return
@@ -66,8 +59,7 @@ export function createSessionBrowser(session: SessionModel) {
  createEffect(() => {
    const sessionID = session.identity.sessionID()
    if (!sessionID) return
-    if (attachments.enabled()) attachments.attach(server, sessionID)
-    onCleanup(attachments.onFocus(server, sessionID, focus))
+    if (attachments.enabled()) attachments.attach(server, sessionID, session.layout.sessionKey())
  })
  createEffect(
    on(
@@ -20,13 +20,18 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
  const command = useCommand()
  const state = props.browser.active
  const address = () => (state()?.url === "about:blank" ? "" : (state()?.url ?? ""))
+  const failed = () => !!state()?.loadError
  const registration = props.browser.registration
  const button = { variant: "ghost", size: "large" } as const
  const [store, setStore] = createStore({
    address: "",
    editing: false,
+    submitted: false,
+    // A submitted navigation the browser has not reported yet; keeps the empty state hidden meanwhile.
+    navigating: false,
    visible: typeof document === "undefined" || document.visibilityState === "visible",
  })
+  const empty = () => !address() && !state()?.loading && !store.navigating
  let surface: HTMLDivElement | undefined
  let addressDisplay: HTMLDivElement | undefined
  let frame: number | undefined
@@ -43,7 +48,7 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
      title: language.t("command.browser.reload"),
      category: language.t("command.category.view"),
      keybind: "f5",
-      disabled: !props.visible || !state(),
+      disabled: !props.visible || !address(),
      onSelect: () => {
        const tab = state()
        if (tab) props.browser.command({ type: "reload", tabID: tab.id })
@@ -71,7 +76,9 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
    const top = Math.round(rect.top * zoom)
    const right = Math.round(rect.right * zoom)
    const bottom = Math.round(rect.bottom * zoom)
-    const visible = props.visible && store.visible && !dialog.active && !covered(rect)
+    // The desktop page hides blank and loading documents itself; only hide here
+    // while the pane shows its own empty or failed state over the surface.
+    const visible = props.visible && store.visible && !empty() && !failed() && !dialog.active && !covered(rect)
    // The cutout exposes the app backdrop outside the rounded Review card,
    // not the browser surface inside it.
    const color = getComputedStyle(
@@ -107,7 +114,25 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
    if (frame === undefined) frame = requestAnimationFrame(tick)
  }

-  createEffect(() => !store.editing && setStore("address", address()))
+  createEffect(on([() => state()?.id, address], () => !store.editing && setStore("address", address())))
+  // Any reported movement, including a rejected or blocked request, ends the submitted navigation.
+  createEffect(
+    on(
+      [() => state()?.id, () => state()?.generation, () => state()?.loading, () => props.browser.error()],
+      () => setStore("navigating", false),
+      { defer: true },
+    ),
+  )
+  // A blocked or rejected submission leaves the page where it was; show that page's URL again.
+  createEffect(
+    on(
+      () => props.browser.error(),
+      (error) => {
+        if (error && !store.editing) setStore("address", address())
+      },
+      { defer: true },
+    ),
+  )
  createEffect(
    on(registration, (current) => {
      // Session routes can change before this pane unmounts. Hide the registration
@@ -123,6 +148,8 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
        () => store.visible,
        () => props.visible,
        () => state()?.id,
+        empty,
+        failed,
        registration,
      ],
      () => {
@@ -157,7 +184,7 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes

  return (
    <aside id="browser-panel" class="relative size-full min-w-0 overflow-hidden bg-v2-background-bg-base flex flex-col">
-      <div class="h-10 shrink-0 flex items-center gap-1 px-2 border-b border-v2-border-border-muted">
+      <div class="h-10 shrink-0 flex items-center gap-1 px-3 border-b border-v2-border-border-muted">
        <For each={["back", "forward"] as const}>
          {(direction) => (
            <Tooltip placement="top" value={language.t(direction === "back" ? "common.goBack" : "common.goForward")}>
@@ -193,7 +220,7 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
        >
          <IconButton
            {...button}
-            disabled={!state()}
+            disabled={!state()?.loading && !address()}
            aria-label={language.t(state()?.loading ? "prompt.action.stop" : "error.page.action.reload")}
            onClick={() => {
              const tab = state()
@@ -212,8 +239,13 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
          onSubmit={(event) => {
            event.preventDefault()
            const tab = state()
-            if (tab && store.address.trim())
-              props.browser.command({ type: "navigate", tabID: tab.id, url: store.address })
+            const url = store.address.trim()
+            if (!tab) return
+            if (url || failed()) {
+              setStore({ submitted: true, address: url, navigating: true })
+              props.browser.command({ type: "navigate", tabID: tab.id, url: url || "about:blank" })
+            }
+            event.currentTarget.querySelector("input")?.blur()
          }}
        >
          <input
@@ -224,8 +256,14 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
            disabled={!state()}
            placeholder={language.t("session.browser.address.placeholder")}
            aria-label={language.t("session.browser.address")}
-            onFocus={() => setStore("editing", true)}
-            onBlur={() => setStore({ editing: false, address: address() })}
+            onFocus={(event) => {
+              setStore("editing", true)
+              event.currentTarget.select()
+            }}
+            onClick={(event) => event.currentTarget.select()}
+            onBlur={() =>
+              setStore({ editing: false, address: store.submitted ? store.address : address(), submitted: false })
+            }
            onInput={(event) => setStore("address", event.currentTarget.value)}
            onScroll={(event) => {
              if (addressDisplay) addressDisplay.scrollLeft = event.currentTarget.scrollLeft
@@ -243,12 +281,27 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
          </div>
        </form>
      </div>
-      <Show when={props.browser.error()}>
+      <Show when={props.browser.error() && !failed()}>
        <div class="shrink-0 px-3 py-1.5 text-12-regular text-text-danger-base border-b border-v2-border-border-muted">
          {props.browser.error()}
        </div>
      </Show>
      <div ref={surface} class="min-h-0 flex-1 bg-v2-background-bg-base flex items-center justify-center">
+        <Show when={(empty() || failed()) && !props.browser.suspended()}>
+          {/* Add the 40px toolbar to the file empty state's 160px bottom padding to align their centers. */}
+          <div
+            dir="auto"
+            class="flex size-full flex-col items-center justify-center gap-2 p-6 pb-[200px] text-center text-text-weak"
+          >
+            <Icon name="globe" size="large" class="mb-2 shrink-0" />
+            <div class="text-[13px] font-medium leading-[var(--line-height-compact)] text-text-strong">
+              {language.t(failed() ? "session.browser.failed.title" : "session.browser.empty.title")}
+            </div>
+            <div class="text-13-regular leading-[var(--line-height-base)]">
+              {language.t(failed() ? "session.browser.failed.description" : "session.browser.empty.description")}
+            </div>
+          </div>
+        </Show>
        <Show when={props.browser.suspended()}>
          <p class="px-6 text-center text-13-regular text-v2-text-text-subtle" role="status">
            {language.t("session.browser.suspended")}
@@ -0,0 +1,94 @@
+/* The control defaults to a fixed 232px with equal segments; here it hugs its two labels. */
+[data-slot="artifact-toolbar"] [data-slot="segmented-control-v2"] {
+  width: auto;
+}
+
+[data-slot="artifact-toolbar"] [data-slot="segmented-control-v2-item"] {
+  flex: 0 0 auto;
+  padding: 0 14px;
+}
+
+/* Shrink-wrapped segments round the label box down a fraction; the ellipsis overflow then clips glyph edges. */
+[data-slot="artifact-toolbar"] [data-slot="segmented-control-v2-item-label"] {
+  overflow: visible;
+  max-width: none;
+}
+
+[data-slot="artifact-stage"] {
+  --artifact-check: color-mix(in oklch, var(--v2-text-text-base) 5%, transparent);
+  background-color: var(--v2-background-bg-deep);
+}
+
+[data-slot="artifact-stage"][data-checker] {
+  background-image:
+    linear-gradient(45deg, var(--artifact-check) 25%, transparent 25%),
+    linear-gradient(-45deg, var(--artifact-check) 25%, transparent 25%),
+    linear-gradient(45deg, transparent 75%, var(--artifact-check) 75%),
+    linear-gradient(-45deg, transparent 75%, var(--artifact-check) 75%);
+  background-size: 16px 16px;
+  background-position:
+    0 0,
+    0 8px,
+    8px -8px,
+    -8px 0;
+}
+
+[data-slot="artifact-media"] {
+  display: block;
+  border-radius: 4px;
+  box-shadow:
+    0 0 0 0.5px var(--v2-border-border-base),
+    0 12px 32px -12px color-mix(in oklch, var(--v2-text-text-base) 25%, transparent);
+}
+
+[data-slot="artifact-stage"][data-zoom="fit"] [data-slot="artifact-media"] {
+  max-width: 100%;
+  max-height: 100%;
+  object-fit: contain;
+}
+
+[data-slot="artifact-stage"][data-zoom="fit"][data-overflow] [data-slot="artifact-media"] {
+  cursor: zoom-in;
+}
+
+[data-slot="artifact-stage"][data-zoom="actual"] [data-slot="artifact-media"] {
+  cursor: zoom-out;
+}
+
+[data-slot="artifact-table"] {
+  border-collapse: separate;
+  border-spacing: 0;
+  font-variant-numeric: tabular-nums;
+}
+
+[data-slot="artifact-table"] th,
+[data-slot="artifact-table"] td {
+  padding: 5px 12px;
+  border-bottom: 1px solid var(--v2-border-border-muted);
+  border-inline-end: 1px solid var(--v2-border-border-muted);
+  white-space: pre;
+  max-width: 40ch;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  text-align: start;
+  line-height: var(--line-height-compact);
+}
+
+[data-slot="artifact-table"] th {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  background: var(--v2-background-bg-layer-01);
+  font-weight: var(--font-weight-medium);
+  color: var(--v2-text-text-muted);
+}
+
+[data-slot="artifact-table"] tbody tr:hover td {
+  background: color-mix(in oklch, var(--v2-text-text-base) 3%, transparent);
+}
+
+[data-slot="artifact-table"] td[data-index] {
+  color: var(--v2-text-text-faint);
+  text-align: end;
+  user-select: none;
+}
@@ -0,0 +1,454 @@
+import { createEffect, createMemo, For, Match, on, onCleanup, Show, Switch, type JSX } from "solid-js"
+import { createStore } from "solid-js/store"
+import { createResizeObserver } from "@solid-primitives/resize-observer"
+import { Button } from "@opencode/ui/button"
+import { FileIcon } from "@opencode/ui/file-icon"
+import { SegmentedControl, SegmentedControlItem } from "@opencode/ui/segmented-control"
+import { ScrollView } from "@opencode/ui/scroll-view"
+import { Markdown } from "@opencode/session-ui/markdown"
+import { MarkdownProvider, useMarkdown } from "@opencode/session-ui/context/markdown"
+import { getDirectory, getFilename } from "@opencode/util/path"
+import type { FileContent } from "@/runtime/server/types"
+import { useLanguage } from "@/runtime/i18n/language"
+import {
+  artifactKind,
+  blobUrlFromContent,
+  contentBytes,
+  parseDelimited,
+  resolveArtifactPath,
+  type ArtifactKind,
+} from "@/workspaces/files/artifact"
+import { useArtifactOpener } from "@/session/files/open-artifact"
+import "./artifact-view.css"
+
+type ArtifactMode = "preview" | "source"
+
+/** Facts a viewer learns from the decoded media, shown in the toolbar. */
+type ArtifactInfo = { width?: number; height?: number; duration?: number; rows?: number; columns?: number }
+
+type MediaProps = {
+  path: string
+  content: FileContent
+  onInfo: (info: ArtifactInfo) => void
+  /** The browser could not decode the bytes; the host falls back to the binary placeholder. */
+  onError: () => void
+}
+
+/** Kinds that render a preview from their text and can toggle back to highlighted source. */
+const previewableKinds = new Set<ArtifactKind>(["svg", "html", "markdown", "mermaid", "table"])
+
+/**
+ * Renders a loaded non-text file: media, documents, and data get a dedicated viewer with a toolbar;
+ * previewable text kinds can switch to `source`, which the host supplies (its code view).
+ */
+export function ArtifactView(props: { path: string; content: FileContent; cacheKey?: string; source: JSX.Element }) {
+  const language = useLanguage()
+  const [state, setState] = createStore({
+    mode: "preview" as ArtifactMode,
+    info: {} as ArtifactInfo,
+    // Media the browser could not decode falls back to the binary placeholder.
+    undecodable: false,
+  })
+  createEffect(
+    on(
+      () => props.content,
+      () => setState({ mode: "preview", info: {}, undecodable: false }),
+      { defer: true },
+    ),
+  )
+
+  const kind = createMemo<ArtifactKind | "binary">(() => {
+    if (props.content.type === "binary" && !props.content.mimeType) return "binary"
+    if (state.undecodable) return "binary"
+    return artifactKind(props.path)
+  })
+  const previewable = createMemo(() => {
+    const value = kind()
+    return value !== "binary" && previewableKinds.has(value)
+  })
+  const meta = createMemo(() => {
+    const info = state.info
+    return [
+      info.width && info.height ? `${info.width} × ${info.height}` : undefined,
+      info.duration ? formatDuration(info.duration) : undefined,
+      info.rows !== undefined ? language.plural("file.view.table.rows", Math.max(0, info.rows - 1)) : undefined,
+      info.columns !== undefined ? language.plural("file.view.table.columns", info.columns) : undefined,
+      formatBytes(language.intl(), contentBytes(props.content)),
+    ].filter((item): item is string => !!item)
+  })
+
+  const media = { onInfo: (info: ArtifactInfo) => setState("info", info), onError: () => setState("undecodable", true) }
+  const rendered = () => (
+    <ScrollView class="min-h-0 flex-1">
+      <Show
+        when={kind() === "markdown"}
+        fallback={<ArtifactMermaid text={props.content.content} cacheKey={props.cacheKey} />}
+      >
+        <ArtifactMarkdown path={props.path} text={props.content.content} cacheKey={props.cacheKey} />
+      </Show>
+    </ScrollView>
+  )
+
+  return (
+    <>
+      <ArtifactToolbar
+        mode={state.mode}
+        onModeChange={previewable() ? (mode) => setState("mode", mode) : undefined}
+        meta={meta()}
+        actions={
+          <Show when={kind() === "html"}>
+            <OpenInBrowserButton path={props.path} />
+          </Show>
+        }
+      />
+      <Show when={!previewable() || state.mode === "preview"} fallback={props.source}>
+        <Switch>
+          <Match when={kind() === "image" || kind() === "svg"}>
+            <ArtifactImage path={props.path} content={props.content} {...media} />
+          </Match>
+          <Match when={kind() === "video"}>
+            <ArtifactVideo path={props.path} content={props.content} {...media} />
+          </Match>
+          <Match when={kind() === "audio"}>
+            <ArtifactAudio path={props.path} content={props.content} {...media} />
+          </Match>
+          <Match when={kind() === "pdf" || kind() === "html"}>
+            <ArtifactFrame path={props.path} content={props.content} kind={kind() === "pdf" ? "pdf" : "html"} />
+          </Match>
+          <Match when={kind() === "font"}>
+            <ArtifactFont path={props.path} content={props.content} />
+          </Match>
+          <Match when={kind() === "table"}>
+            <ArtifactTable path={props.path} text={props.content.content} onInfo={media.onInfo} />
+          </Match>
+          <Match when={kind() === "markdown" || kind() === "mermaid"}>{rendered()}</Match>
+          <Match when={kind() === "binary"}>
+            <ArtifactBinary path={props.path} size={formatBytes(language.intl(), contentBytes(props.content))} />
+          </Match>
+        </Switch>
+      </Show>
+    </>
+  )
+}
+
+function formatBytes(locale: string, bytes: number) {
+  const units = ["byte", "kilobyte", "megabyte", "gigabyte"] as const
+  const index = Math.min(units.length - 1, bytes > 0 ? Math.floor(Math.log10(bytes) / 3) : 0)
+  const value = bytes / 1000 ** index
+  return new Intl.NumberFormat(locale, {
+    style: "unit",
+    unit: units[index],
+    // "short" bytes render as the singular "byte"; the long form pluralizes correctly.
+    unitDisplay: index === 0 ? "long" : "short",
+    maximumFractionDigits: value >= 100 || index === 0 ? 0 : 1,
+  }).format(value)
+}
+
+function formatDuration(seconds: number) {
+  const total = Math.round(seconds)
+  const minutes = Math.floor(total / 60)
+  return `${minutes}:${String(total % 60).padStart(2, "0")}`
+}
+
+function ArtifactToolbar(props: {
+  mode?: ArtifactMode
+  onModeChange?: (mode: ArtifactMode) => void
+  meta: string[]
+  actions?: JSX.Element
+}) {
+  const language = useLanguage()
+  return (
+    <div data-slot="artifact-toolbar" class="flex h-10 shrink-0 items-center gap-3 px-4">
+      <Show when={props.onModeChange}>
+        <SegmentedControl
+          value={props.mode ?? "preview"}
+          onChange={(value) => {
+            if (value === "preview" || value === "source") props.onModeChange?.(value)
+          }}
+        >
+          <SegmentedControlItem value="preview">{language.t("file.view.preview")}</SegmentedControlItem>
+          <SegmentedControlItem value="source">{language.t("file.view.source")}</SegmentedControlItem>
+        </SegmentedControl>
+      </Show>
+      <div class="ms-auto flex min-w-0 items-center gap-3">
+        <div class="flex min-w-0 items-center gap-2 text-12-regular text-text-weak">
+          <For each={props.meta}>
+            {(item, index) => (
+              <>
+                <Show when={index() > 0}>
+                  <span aria-hidden class="text-text-faint">
+                    ·
+                  </span>
+                </Show>
+                <span class="truncate tabular-nums">{item}</span>
+              </>
+            )}
+          </For>
+        </div>
+        {props.actions}
+      </div>
+    </div>
+  )
+}
+
+function OpenInBrowserButton(props: { path: string }) {
+  const language = useLanguage()
+  const artifacts = useArtifactOpener()
+  return (
+    <Show when={artifacts.canOpenInBrowser(props.path)}>
+      <Button size="small" variant="ghost" icon="globe" onClick={() => artifacts.openInBrowser(props.path)}>
+        {language.t("file.view.openInBrowser")}
+      </Button>
+    </Show>
+  )
+}
+
+function createBlobUrl(content: () => FileContent) {
+  return createMemo(() => {
+    const value = blobUrlFromContent(content())
+    onCleanup(() => URL.revokeObjectURL(value))
+    return value
+  })
+}
+
+/** Images and SVG previews: fit the pane, click to inspect at 1:1 when the image is larger. */
+function ArtifactImage(props: MediaProps) {
+  const url = createBlobUrl(() => props.content)
+  const [state, setState] = createStore({ zoom: "fit" as "fit" | "actual", overflow: false, width: 0, height: 0 })
+  let stage: HTMLDivElement | undefined
+  const measure = () => {
+    if (!stage) return
+    setState("overflow", state.width > stage.clientWidth - 48 || state.height > stage.clientHeight - 48)
+  }
+  createResizeObserver(
+    () => stage,
+    () => measure(),
+  )
+  createEffect(() => {
+    url()
+    setState({ zoom: "fit", overflow: false })
+  })
+  return (
+    <div
+      ref={stage}
+      data-slot="artifact-stage"
+      data-checker
+      data-zoom={state.zoom}
+      data-overflow={state.overflow || undefined}
+      class="relative min-h-0 flex-1 overflow-auto"
+    >
+      <div
+        classList={{
+          "absolute inset-0 flex items-center justify-center p-6": state.zoom === "fit",
+          "flex min-h-full min-w-full w-max items-center justify-center p-6": state.zoom === "actual",
+        }}
+      >
+        <img
+          data-slot="artifact-media"
+          src={url()}
+          alt={getFilename(props.path)}
+          draggable={false}
+          onError={() => props.onError()}
+          onLoad={(event) => {
+            const image = event.currentTarget
+            setState({ width: image.naturalWidth, height: image.naturalHeight })
+            props.onInfo({ width: image.naturalWidth, height: image.naturalHeight })
+            measure()
+          }}
+          onClick={() => {
+            if (!state.overflow && state.zoom === "fit") return
+            setState("zoom", state.zoom === "fit" ? "actual" : "fit")
+          }}
+        />
+      </div>
+    </div>
+  )
+}
+
+function ArtifactVideo(props: MediaProps) {
+  const url = createBlobUrl(() => props.content)
+  return (
+    <div data-slot="artifact-stage" data-zoom="fit" class="relative min-h-0 flex-1 overflow-hidden">
+      <div class="absolute inset-0 flex items-center justify-center p-6">
+        <video
+          data-slot="artifact-media"
+          class="w-full bg-black"
+          controls
+          preload="metadata"
+          playsinline
+          onError={() => props.onError()}
+          src={url()}
+          onLoadedMetadata={(event) => {
+            const video = event.currentTarget
+            props.onInfo({ width: video.videoWidth, height: video.videoHeight, duration: video.duration })
+          }}
+        />
+      </div>
+    </div>
+  )
+}
+
+function ArtifactAudio(props: MediaProps) {
+  const url = createBlobUrl(() => props.content)
+  return (
+    <div data-slot="artifact-stage" class="relative min-h-0 flex-1 overflow-auto">
+      <div class="absolute inset-0 flex items-center justify-center p-6">
+        <div class="flex w-full max-w-lg flex-col items-center gap-5 rounded-xl border border-v2-border-border-muted bg-v2-background-bg-base px-8 py-8 shadow-[var(--v2-elevation-raised)]">
+          <div class="flex size-14 items-center justify-center rounded-full bg-v2-background-bg-layer-02">
+            <FileIcon node={{ path: props.path, type: "file" }} class="size-7" />
+          </div>
+          <div class="max-w-full truncate text-14-medium text-text-strong">{getFilename(props.path)}</div>
+          <audio
+            class="w-full"
+            onError={() => props.onError()}
+            controls
+            preload="metadata"
+            src={url()}
+            onLoadedMetadata={(event) => props.onInfo({ duration: event.currentTarget.duration })}
+          />
+        </div>
+      </div>
+    </div>
+  )
+}
+
+function ArtifactFrame(props: { path: string; content: FileContent; kind: "pdf" | "html" }) {
+  const url = createBlobUrl(() => props.content)
+  // PDF Open Parameters: start with the thumbnail pane closed and the page fitted to the pane width.
+  const src = () => (props.kind === "pdf" ? `${url()}#navpanes=0&view=FitH` : url())
+  return (
+    <iframe
+      class="block h-full w-full flex-1 border-0 bg-white"
+      title={getFilename(props.path)}
+      src={src()}
+      // The PDF viewer is Chromium's own and does not run in a sandboxed frame. HTML runs as an
+      // opaque origin: no app storage, cookies, or credentialed requests reach it.
+      sandbox={props.kind === "html" ? "allow-scripts allow-popups allow-forms allow-modals" : undefined}
+      referrerPolicy="no-referrer"
+    />
+  )
+}
+
+function ArtifactMarkdown(props: { path: string; text: string; cacheKey?: string }) {
+  const parent = useMarkdown()
+  const artifacts = useArtifactOpener()
+  // getDirectory yields "/" for a root-level file, which would make relative links absolute.
+  const dir = createMemo(() => (props.path.includes("/") || props.path.includes("\\") ? getDirectory(props.path) : ""))
+  // Absolute references bypass the file's directory; relative ones resolve against it.
+  const resolve = (href: string) => (/^([a-z]:)?\//i.test(href) ? href : (resolveArtifactPath(dir(), href) ?? href))
+  return (
+    <MarkdownProvider
+      readImage={(src, signal) => parent?.readImage?.(resolve(src), signal) ?? Promise.resolve(undefined)}
+      openLocalFile={(href) => artifacts.open(href, dir())}
+    >
+      <div class="mx-auto w-full max-w-3xl px-8 py-6">
+        <Markdown text={props.text} cacheKey={props.cacheKey} class="select-text" />
+      </div>
+    </MarkdownProvider>
+  )
+}
+
+/** Mermaid sources render through the same fenced-block pipeline the timeline uses. */
+function ArtifactMermaid(props: { text: string; cacheKey?: string }) {
+  return (
+    <div class="mx-auto w-full max-w-4xl px-8 py-6">
+      <Markdown text={`\`\`\`mermaid\n${props.text}\n\`\`\``} cacheKey={props.cacheKey} class="select-text" />
+    </div>
+  )
+}
+
+function ArtifactTable(props: { path: string; text: string; onInfo: (info: ArtifactInfo) => void }) {
+  const language = useLanguage()
+  const parsed = createMemo(() => parseDelimited(props.text, props.path.toLowerCase().endsWith(".tsv") ? "\t" : ","))
+  createEffect(() => props.onInfo({ rows: parsed().total, columns: parsed().columns }))
+  // Pad the header to the widest row so no data column is dropped.
+  const header = () => Array.from({ length: parsed().columns }, (_, index) => parsed().rows[0]?.[index] ?? "")
+  const body = () => parsed().rows.slice(1)
+  return (
+    <div class="min-h-0 flex-1 overflow-auto">
+      <table data-slot="artifact-table" class="min-w-full text-13-regular text-text-base">
+        <thead>
+          <tr>
+            <th data-index />
+            <For each={header()}>{(cell) => <th>{cell}</th>}</For>
+          </tr>
+        </thead>
+        <tbody>
+          <For each={body()}>
+            {(row, index) => (
+              <tr>
+                <td data-index>{index() + 1}</td>
+                <For each={header()}>{(_, column) => <td>{row[column()] ?? ""}</td>}</For>
+              </tr>
+            )}
+          </For>
+        </tbody>
+      </table>
+      <Show when={parsed().total > parsed().rows.length}>
+        <div class="px-4 py-3 text-12-regular text-text-weak">
+          {language.t("file.view.table.truncated", { shown: parsed().rows.length - 1, total: parsed().total - 1 })}
+        </div>
+      </Show>
+    </div>
+  )
+}
+
+const specimenSizes = [12, 16, 24, 40, 64]
+
+function ArtifactFont(props: { path: string; content: FileContent }) {
+  const language = useLanguage()
+  const url = createBlobUrl(() => props.content)
+  const family = createMemo(() => `artifact-${Math.random().toString(36).slice(2)}`)
+  createEffect(() => {
+    const face = new FontFace(family(), `url(${url()})`)
+    document.fonts.add(face)
+    void face.load().catch(() => undefined)
+    onCleanup(() => document.fonts.delete(face))
+  })
+  return (
+    <div class="min-h-0 flex-1 overflow-auto">
+      <div class="mx-auto flex w-full max-w-3xl flex-col gap-6 px-8 py-8" style={{ "font-family": `"${family()}"` }}>
+        <div class="text-text-strong" style={{ "font-size": "56px", "line-height": "1.1" }}>
+          {getFilename(props.path).replace(/\.[^.]+$/, "")}
+        </div>
+        <div class="break-all text-text-base" style={{ "font-size": "22px", "line-height": "1.4" }}>
+          ABCDEFGHIJKLMNOPQRSTUVWXYZ
+          <br />
+          abcdefghijklmnopqrstuvwxyz
+          <br />
+          0123456789 !?&@#%(){}[]
+        </div>
+        <div class="flex flex-col gap-3 border-t border-v2-border-border-muted pt-6">
+          <For each={specimenSizes}>
+            {(size) => (
+              <div class="flex items-baseline gap-4">
+                <span
+                  class="w-8 shrink-0 text-12-regular text-text-faint tabular-nums"
+                  style={{ "font-family": "var(--font-family-mono)" }}
+                >
+                  {size}
+                </span>
+                <span class="text-text-base" style={{ "font-size": `${size}px`, "line-height": "1.25" }}>
+                  {language.t("file.view.fontSample")}
+                </span>
+              </div>
+            )}
+          </For>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+function ArtifactBinary(props: { path: string; size: string }) {
+  const language = useLanguage()
+  return (
+    <div data-slot="artifact-stage" class="relative min-h-0 flex-1">
+      <div class="absolute inset-0 flex flex-col items-center justify-center gap-3 p-6 text-center">
+        <FileIcon node={{ path: props.path, type: "file" }} class="size-8 text-text-weak" />
+        <div class="text-14-medium text-text-strong">{getFilename(props.path)}</div>
+        <div class="text-13-regular text-text-weak">{language.t("file.view.binary", { size: props.size })}</div>
+      </div>
+    </div>
+  )
+}
@@ -1,4 +1,4 @@
-import { createEffect, createMemo, createSignal, Match, on, onCleanup, Switch } from "solid-js"
+import { createEffect, createMemo, createSignal, Match, on, onCleanup, Show, Switch } from "solid-js"
 import { createStore } from "solid-js/store"
 import { Dynamic } from "solid-js/web"
 import { makeEventListener } from "@solid-primitives/event-listener"
@@ -11,8 +11,9 @@ import { LineCommentOverflowIcon } from "@opencode/ui/line-comment"
 import { Menu } from "@opencode/ui/menu"
 import { Tabs } from "@opencode/ui/tabs"
 import { ScrollView } from "@opencode/ui/scroll-view"
-import { showToast } from "@/shell/notifications/toast"
 import { selectionFromLines, useFile, type FileSelection, type SelectedLineRange } from "@/workspaces/files/model"
+import { artifactKind } from "@/workspaces/files/artifact"
+import { ArtifactView } from "@/session/files/artifact-view"
 import { useComments } from "@/composer/comments"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useComposerState } from "@/composer/persistence"
@@ -205,6 +206,11 @@ export function SessionFileView(props: SessionFileViewProps) {
  })
  const contents = createMemo(() => state()?.content?.content ?? "")
  const cacheKey = createMemo(() => sampledChecksum(contents()))
+  // Plain text keeps the code view; every other kind is rendered by ArtifactView.
+  const artifact = createMemo(() => {
+    const content = state()?.content
+    return content?.type === "binary" || artifactKind(path() ?? "") !== "text"
+  })
  const selectedLines = createMemo<SelectedLineRange | null>(() => {
    const p = path()
    if (!p) return null
@@ -433,39 +439,42 @@ export function SessionFileView(props: SessionFileViewProps) {
        }}
        search={search}
        class="select-text"
-        media={{
-          mode: "auto",
-          path: path(),
-          current: state()?.content,
-          onLoad: scrollSync.queueRestore,
-          onError: (args: { kind: "image" | "audio" | "svg" }) => {
-            if (args.kind !== "svg") return
-            showToast({
-              variant: "error",
-              title: language.t("toast.file.loadFailed.title"),
-            })
-          },
-        }}
+        // Media and previews have their own viewers below; the code view only ever shows text.
+        media={{ mode: "off" }}
      />
    </div>
  )

+  // The code view scrolls inside ScrollView so line state and scroll position persist per tab.
+  const codeView = (source: string) => (
+    <ScrollView class="min-h-0 flex-1" viewportRef={scrollSync.setViewport} onScroll={scrollSync.handleScroll}>
+      {renderFile(source)}
+    </ScrollView>
+  )
+
  const content = () => (
-    <div class="mt-3 relative h-full min-h-0">
-      <ScrollView class="h-full" viewportRef={scrollSync.setViewport} onScroll={scrollSync.handleScroll}>
-        <Switch>
-          <Match when={state()?.loaded}>{renderFile(contents())}</Match>
-          <Match when={state()?.loading}>
-            <div class="px-6 py-4 text-text-weak">{language.t("common.loading")}…</div>
-          </Match>
-          <Match when={state()?.notFound ? state()?.name : undefined}>
-            {(name) => (
-              <div class="px-6 py-4 text-text-weak">{language.t("file.error.notFound", { name: name() })}</div>
-            )}
-          </Match>
-          <Match when={state()?.error}>{(err) => <div class="px-6 py-4 text-text-weak">{err()}</div>}</Match>
-        </Switch>
-      </ScrollView>
+    <div class="mt-3 relative h-full min-h-0 flex flex-col">
+      <Switch>
+        <Match when={state()?.loaded ? state()?.content : undefined}>
+          {(value) => (
+            <Show when={artifact()} fallback={codeView(value().content)}>
+              <ArtifactView
+                path={path() ?? ""}
+                content={value()}
+                cacheKey={cacheKey()}
+                source={codeView(value().content)}
+              />
+            </Show>
+          )}
+        </Match>
+        <Match when={state()?.loading}>
+          <div class="px-6 py-4 text-text-weak">{language.t("common.loading")}…</div>
+        </Match>
+        <Match when={state()?.notFound ? state()?.name : undefined}>
+          {(name) => <div class="px-6 py-4 text-text-weak">{language.t("file.error.notFound", { name: name() })}</div>}
+        </Match>
+        <Match when={state()?.error}>{(err) => <div class="px-6 py-4 text-text-weak">{err()}</div>}</Match>
+      </Switch>
    </div>
  )

@@ -0,0 +1,105 @@
+import { createEffect, onCleanup, type ParentProps } from "solid-js"
+import { createSimpleContext } from "@opencode/ui/context"
+import { MarkdownProvider, useMarkdown } from "@opencode/session-ui/context/markdown"
+import { useBrowserAttachments } from "@/session/browser/attachments"
+import type { SessionModel } from "@/session/model"
+import { useFile } from "@/workspaces/files/model"
+import { artifactKind, resolveArtifactPath } from "@/workspaces/files/artifact"
+import { encodeFilePath } from "@/workspaces/files/path"
+import { useWorkspaceLocation } from "@/workspaces/location"
+import { useServer } from "@/runtime/server/current"
+import { ServerConnection } from "@/runtime/server/registry"
+import { useSessionLayout } from "@/session/session-layout"
+import { createOpenSessionFileTab } from "@/session/helpers"
+import type { createSessionBrowser } from "@/session/browser/model"
+
+/** Routes local links in timeline markdown to the artifact opener while keeping image loading. */
+export function ArtifactMarkdownProvider(props: ParentProps) {
+  const markdown = useMarkdown()
+  const artifacts = useArtifactOpener()
+  return (
+    <MarkdownProvider readImage={markdown?.readImage} openLocalFile={(path) => artifacts.open(path)}>
+      {props.children}
+    </MarkdownProvider>
+  )
+}
+
+/**
+ * Opens files the agent references as side-panel tabs, inside or outside the workspace, or as
+ * a browser tab for HTML when the desktop can load the file directly.
+ */
+export const { use: useArtifactOpener, provider: ArtifactOpenerProvider } = createSimpleContext({
+  name: "ArtifactOpener",
+  init: (props: { session: SessionModel; browser: ReturnType<typeof createSessionBrowser> }) => {
+    const file = useFile()
+    const server = useServer()
+    const location = useWorkspaceLocation()
+    const attachments = useBrowserAttachments()
+    const { tabs, view } = useSessionLayout()
+
+    const root = () => location().directory.replaceAll("\\", "/").replace(/\/+$/, "")
+
+    /**
+     * Turn a link into a path `useFile` can load: workspace-relative when it is under the root,
+     * otherwise absolute. Relative links resolve against `base`; ones that climb past the root
+     * become absolute too, so a `../../shared/report.pdf` still opens.
+     */
+    const resolve = (href: string, base?: string) => {
+      // Agents cite locations as path:line or path:line:col; the file is what opens.
+      const value = href.replaceAll("\\", "/").replace(/:\d+(?::\d+)?$/, "")
+      if (/^[a-z]:\//i.test(value) || value.startsWith("/")) return file.normalize(value)
+      const relative = resolveArtifactPath(base ?? "", value)
+      if (relative !== undefined) return file.normalize(relative)
+      // Climbing past the workspace root: resolve from the referencing folder's absolute location.
+      const dir = base ? `${root()}/${base.replace(/\/+$/, "")}` : root()
+      return file.normalize(resolveArtifactPath(dir, value) ?? value)
+    }
+
+    const showTab = createOpenSessionFileTab({
+      normalizeTab: (tab) => tab,
+      openTab: (tab) => tabs().open(tab),
+      pathFromTab: file.pathFromTab,
+      loadFile: () => undefined,
+      openReviewPanel: () => {
+        if (!view().reviewPanel.opened()) view().reviewPanel.open()
+      },
+      setActive: (tab) => tabs().setActive(tab),
+    })
+
+    // Inline paths are guessed from text, so confirm the file exists before a tab appears for it.
+    const openTab = (path: string) => {
+      void file.load(path).then(() => {
+        if (file.get(path)?.loaded) showTab(file.tab(path))
+      })
+    }
+
+    // The desktop's own sidecar shares this disk, and its browser pane accepts file:// URLs inside the
+    // session workspace only. Forwarded loopback servers do not qualify, matching the desktop policy.
+    const canOpenInBrowser = (path?: string) =>
+      ServerConnection.builtin(server.conn) &&
+      props.browser.available() &&
+      props.browser.attached() &&
+      (path === undefined || !file.absolute(path))
+
+    const openInBrowser = (path: string) => {
+      props.browser.command({ type: "tabs.open", url: `file://${encodeFilePath(`${root()}/${path}`)}` })
+    }
+
+    /** Open `href` as referenced from `base` (a workspace-relative directory, "" for the root). */
+    const open = (href: string, base?: string) => {
+      const path = resolve(href, base)
+      if (!path) return
+      if (artifactKind(path) === "html" && canOpenInBrowser(path)) return openInBrowser(path)
+      openTab(path)
+    }
+
+    // The agent's browser.preview tool arrives through the desktop browser pane attachment.
+    createEffect(() => {
+      const sessionID = props.session.identity.sessionID()
+      if (!sessionID) return
+      onCleanup(attachments.onPreview(server, sessionID, (path) => open(path)))
+    })
+
+    return { canOpenInBrowser, openInBrowser, open }
+  },
+})
@@ -173,7 +173,9 @@ export function SessionFileBrowserTab(props: {
          <SessionFilePanelV2Empty>
            <div class="flex flex-col items-center gap-2 text-center text-text-weak">
              <Icon name="file-tree" size="large" class="mb-2" />
-              <div class="text-[13px] font-medium leading-[13px] text-text-strong">{language.t("command.file.open")}</div>
+              <div class="text-[13px] font-medium leading-[13px] text-text-strong">
+                {language.t("command.file.open")}
+              </div>
              <div class="h-5 text-13-regular leading-5">{language.t("session.files.selectToOpen")}</div>
            </div>
          </SessionFilePanelV2Empty>
@@ -1,6 +1,8 @@
 import { children, createMemo, Show } from "solid-js"
 import type { JSX } from "solid-js"
 import { useSortable } from "@dnd-kit/solid/sortable"
+import { Icon } from "@opencode/ui/icon"
+import { IconButton } from "@opencode/ui/icon-button"
 import { Keybind } from "@opencode/ui/keybind"
 import { Tooltip } from "@opencode/ui/tooltip"
 import { Tabs } from "@opencode/ui/tabs"
@@ -69,9 +71,19 @@ export function SortableTab(props: {
              placement="bottom"
              gutter={10}
            >
-              <Tabs.CloseButton
-                class="h-5 w-5"
-                onClick={() => props.onTabClose(props.tab)}
+              <IconButton
+                size="small"
+                variant="ghost-muted"
+                onPointerDown={(event) => {
+                  event.preventDefault()
+                  event.stopPropagation()
+                }}
+                onClick={(event) => {
+                  event.preventDefault()
+                  event.stopPropagation()
+                  props.onTabClose(props.tab)
+                }}
+                icon={<Icon name="xmark-small" />}
                aria-label={language.t("common.closeTab")}
              />
            </Tooltip>
@@ -137,6 +137,7 @@ export function useSessionModel() {
      tabs: layout.tabs,
      view: layout.view,
      tabKey: layout.tabKey,
+      sessionKey: layout.sessionKey,
    },
    ownership: createSessionOwnership(layout.sessionKey),
    tabs: {
@@ -155,6 +155,9 @@ export function createSessionReview(input: {
  const count = () => diffs().length
  const hasChanges = () => count() > 0
  const ready = () => {
+    // A project without VCS never enables vcsQuery, so its status stays "pending" forever.
+    const project = input.session.project()
+    if (project && !project.vcs) return true
    if (mode() === "git" || mode() === "branch") return !vcsQuery.isPending
    return true
  }
@@ -249,7 +249,7 @@ function ReviewTitle(props: { review: SessionReviewModel }) {
 function ReviewEmpty(props: { review: SessionReviewModel; loadingClass: string }) {
  const language = useLanguage()
  const loading = () => (props.review.mode() === "git" || props.review.mode() === "branch") && !props.review.ready()
-  const noGit = () => props.review.mode() === "turn" && props.review.noGit()
+  const noGit = () => props.review.noGit()
  const text = () => {
    if (props.review.mode() === "git") return language.t("session.review.noUncommittedChanges")
    if (props.review.mode() === "branch") return language.t("session.review.noBranchChanges")
@@ -282,7 +282,7 @@ function ReviewEmpty(props: { review: SessionReviewModel; loadingClass: string }
 function ReviewPanelEmpty(props: { review: SessionReviewModel }) {
  const language = useLanguage()
  const loading = () => (props.review.mode() === "git" || props.review.mode() === "branch") && !props.review.ready()
-  const noGit = () => props.review.mode() === "turn" && props.review.noGit()
+  const noGit = () => props.review.noGit()
  return (
    <Switch>
      <Match when={loading()}>
@@ -38,6 +38,7 @@ import { SessionReviewToggle } from "./header/session-header-actions"
 import { createAnimatedPresence } from "@/runtime/animated-presence"
 import { createSessionBrowser } from "./browser/model"
 import { createTimelineCache } from "./timeline/cache"
+import { ArtifactMarkdownProvider, ArtifactOpenerProvider } from "./files/open-artifact"

 const SessionMobileFiles = lazy(async () => {
  const { SessionMobileFiles } = await import("./files/session-mobile-files")
@@ -50,14 +51,26 @@ const SessionSummaryPanel = lazy(async () => {
 })

 export function SessionScreen(props: { session: SessionModel }) {
+  // The timeline cache captures its owner when created, so link handling must be provided above it.
+  const browser = createSessionBrowser(props.session)
+  return (
+    <ArtifactOpenerProvider session={props.session} browser={browser}>
+      <ArtifactMarkdownProvider>
+        <SessionScreenContent session={props.session} browser={browser} />
+      </ArtifactMarkdownProvider>
+    </ArtifactOpenerProvider>
+  )
+}
+
+function SessionScreenContent(props: { session: SessionModel; browser: ReturnType<typeof createSessionBrowser> }) {
  const session = props.session
+  const browser = props.browser
  const server = useServer()
  const detailsProject = createMemo(() => {
    const info = session.data.info()
    return info ? projectForSession(info, server.ctx.sync.data.project) : undefined
  })
  const isDesktop = session.isDesktop
-  const browser = createSessionBrowser(session)
  const screen = createSessionScreenLayout(session)
  const timeline = createSessionTimelineInteraction(session)
  const timelineSearch = createTimelineSearchController({
@@ -1102,10 +1102,6 @@
  padding-block: 20px;
 }

-.settings-server-connection .settings-servers-lead {
-  gap: 4px;
-}
-
 .settings-servers-row:not(:last-child) {
  padding-bottom: 16px;
  margin-bottom: 16px;
@@ -9,7 +9,8 @@
  justify-content: center;
 }

-[data-titlebar-tab] {
+[data-titlebar-tab],
+[data-titlebar-tab-action] {
  --tab-base: var(--v2-background-bg-deep);
  --tab-overlay: transparent;
  background: linear-gradient(var(--tab-overlay), var(--tab-overlay)), var(--tab-base);
@@ -68,6 +69,14 @@
  --tab-overlay: var(--v2-overlay-simple-overlay-pressed);
 }

+[data-titlebar-tab-action]:is(:hover, :focus-visible) {
+  --tab-overlay: var(--v2-overlay-simple-overlay-hover);
+}
+
+[data-titlebar-tab-action]:is(:active, [data-state="pressed"]) {
+  --tab-overlay: var(--v2-overlay-simple-overlay-pressed);
+}
+
 [data-titlebar-tab]:is(:hover, [data-state="pressed"]) [data-slot="tab-close"] {
  background: linear-gradient(var(--tab-overlay), var(--tab-overlay)), var(--tab-base);
 }
@@ -351,9 +351,10 @@ export function Titlebar(props: {
              >
                <button
                  type="button"
+                  data-titlebar-tab-action
                  data-action="vertical-tabs-home"
                  data-state={layout.route().type === "home" ? "pressed" : undefined}
-                  class="group mb-1 flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base data-[state=pressed]:bg-v2-background-bg-layer-02 data-[state=pressed]:text-v2-text-text-base"
+                  class="group mb-1 flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:text-v2-text-text-base data-[state=pressed]:text-v2-text-text-base"
                  onClick={toggleHome}
                  aria-label={language.t("home.title")}
                  aria-pressed={layout.route().type === "home"}
@@ -650,8 +651,9 @@ export function Titlebar(props: {
                            {homeButton(true)}
                            <button
                              type="button"
+                              data-titlebar-tab-action
                              data-action="vertical-tabs-new-session"
-                              class="group flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base"
+                              class="group flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:text-v2-text-text-base"
                              onClick={openNewTab}
                              aria-label={language.t("command.session.new")}
                            >
@@ -0,0 +1,118 @@
+import { describe, expect, test } from "bun:test"
+import {
+  artifactKind,
+  bytesToBase64,
+  contentBytes,
+  fileContentFromBytes,
+  MAX_MEDIA_BYTES,
+  parseDelimited,
+  resolveArtifactPath,
+} from "./artifact"
+
+describe("artifactKind", () => {
+  test.each([
+    ["shot.PNG", "image"],
+    ["logo.svg", "svg"],
+    ["song.mp3", "audio"],
+    ["demo.mp4", "video"],
+    ["clip.webm", "video"],
+    ["paper.pdf", "pdf"],
+    ["out/index.html", "html"],
+    ["README.md", "markdown"],
+    ["flow.mmd", "mermaid"],
+    ["data.csv", "table"],
+    ["data.tsv", "table"],
+    ["Inter.woff2", "font"],
+    ["src/app.ts", "text"],
+    ["Makefile", "text"],
+    [".env", "text"],
+    ["archive.tar.gz", "text"],
+  ] as const)("classifies %s as %s", (path, kind) => {
+    expect(artifactKind(path)).toBe(kind)
+  })
+})
+
+describe("fileContentFromBytes", () => {
+  test("keeps media as base64 with a mime type", () => {
+    const content = fileContentFromBytes("a.png", new Uint8Array([137, 80, 78, 71]))
+    expect(content).toEqual({ type: "binary", content: "iVBORw==", encoding: "base64", mimeType: "image/png" })
+  })
+
+  test("decodes text and svg with a mime type", () => {
+    expect(fileContentFromBytes("a.svg", new TextEncoder().encode("<svg/>"))).toEqual({
+      type: "text",
+      content: "<svg/>",
+      mimeType: "image/svg+xml",
+    })
+    expect(fileContentFromBytes("a.ts", new TextEncoder().encode("const a = 1"))).toEqual({
+      type: "text",
+      content: "const a = 1",
+      mimeType: undefined,
+    })
+  })
+
+  test("keeps only the size of media above the cap", () => {
+    const content = fileContentFromBytes("big.mp4", new Uint8Array(MAX_MEDIA_BYTES + 1))
+    expect(content).toEqual({ type: "binary", content: "", size: MAX_MEDIA_BYTES + 1 })
+  })
+
+  test("marks unknown binaries without keeping bytes", () => {
+    expect(fileContentFromBytes("a.bin", new Uint8Array([1, 0, 2]))).toEqual({ type: "binary", content: "", size: 3 })
+  })
+
+  test("encodes large buffers in chunks", () => {
+    const bytes = new Uint8Array(70_000).fill(65)
+    expect(bytesToBase64(bytes)).toBe(Buffer.from(bytes).toString("base64"))
+  })
+})
+
+describe("contentBytes", () => {
+  test("recovers byte counts from base64 and text", () => {
+    expect(contentBytes({ type: "binary", content: "iVBORw==", encoding: "base64" })).toBe(4)
+    expect(contentBytes({ type: "binary", content: "iVBORwA=", encoding: "base64" })).toBe(5)
+    expect(contentBytes({ type: "text", content: "héllo" })).toBe(6)
+  })
+})
+
+describe("parseDelimited", () => {
+  test("handles quotes, embedded delimiters, newlines, and CRLF", () => {
+    const parsed = parseDelimited('name,note\r\n"Smith, J","says ""hi""\nand more"\nplain,\n', ",")
+    expect(parsed.rows).toEqual([
+      ["name", "note"],
+      ["Smith, J", 'says "hi"\nand more'],
+      ["plain", ""],
+    ])
+    expect(parsed.total).toBe(3)
+    expect(parsed.columns).toBe(2)
+  })
+
+  test("counts rows past the limit without keeping them", () => {
+    const parsed = parseDelimited("a\tb\n1\t2\n3\t4\n5\t6", "\t", 2)
+    expect(parsed.rows).toHaveLength(2)
+    expect(parsed.total).toBe(4)
+  })
+})
+
+describe("resolveArtifactPath", () => {
+  test.each([
+    ["docs", "guide.md", "docs/guide.md"],
+    ["docs", "./img/a.png", "docs/img/a.png"],
+    ["docs/api", "../index.md", "docs/index.md"],
+    ["", "src/app.ts", "src/app.ts"],
+    ["docs", "sub\\win.md", "docs/sub/win.md"],
+    ["", "docs/guide.md", "docs/guide.md"],
+    ["/tmp/notes/", "../out/a.pdf", "/tmp/out/a.pdf"],
+    ["C:/tmp/notes/", "img.png", "C:/tmp/notes/img.png"],
+    ["/repo", "../shared/report.pdf", "/shared/report.pdf"],
+  ])("resolves %s + %s", (base, href, expected) => {
+    expect(resolveArtifactPath(base, href)).toBe(expected)
+  })
+
+  test.each([
+    ["docs", "../../etc/passwd"],
+    ["", "../x"],
+    ["docs", "/abs/path"],
+  ])("rejects %s + %s", (base, href) => {
+    expect(resolveArtifactPath(base, href)).toBeUndefined()
+  })
+})
@@ -0,0 +1,211 @@
+import type { FileContent } from "@/runtime/server/types"
+
+export type ArtifactKind =
+  | "image"
+  | "svg"
+  | "audio"
+  | "video"
+  | "pdf"
+  | "html"
+  | "markdown"
+  | "mermaid"
+  | "table"
+  | "font"
+  | "text"
+
+const mimes = new Map([
+  ["png", "image/png"],
+  ["jpg", "image/jpeg"],
+  ["jpeg", "image/jpeg"],
+  ["gif", "image/gif"],
+  ["webp", "image/webp"],
+  ["avif", "image/avif"],
+  ["bmp", "image/bmp"],
+  ["ico", "image/x-icon"],
+  ["tif", "image/tiff"],
+  ["tiff", "image/tiff"],
+  ["heic", "image/heic"],
+  ["svg", "image/svg+xml"],
+  ["mp3", "audio/mpeg"],
+  ["wav", "audio/wav"],
+  ["ogg", "audio/ogg"],
+  ["oga", "audio/ogg"],
+  ["m4a", "audio/mp4"],
+  ["aac", "audio/aac"],
+  ["flac", "audio/flac"],
+  ["opus", "audio/ogg"],
+  ["weba", "audio/webm"],
+  ["mp4", "video/mp4"],
+  ["m4v", "video/mp4"],
+  ["webm", "video/webm"],
+  ["mov", "video/quicktime"],
+  ["ogv", "video/ogg"],
+  ["mkv", "video/x-matroska"],
+  ["pdf", "application/pdf"],
+  ["html", "text/html"],
+  ["htm", "text/html"],
+  ["md", "text/markdown"],
+  ["markdown", "text/markdown"],
+  ["mdx", "text/markdown"],
+  ["mmd", "text/vnd.mermaid"],
+  ["mermaid", "text/vnd.mermaid"],
+  ["csv", "text/csv"],
+  ["tsv", "text/tab-separated-values"],
+  ["ttf", "font/ttf"],
+  ["otf", "font/otf"],
+  ["woff", "font/woff"],
+  ["woff2", "font/woff2"],
+])
+
+export function artifactExtension(path: string) {
+  const name = path.split(/[\\/]/).pop() ?? ""
+  const index = name.lastIndexOf(".")
+  if (index <= 0) return ""
+  return name.slice(index + 1).toLowerCase()
+}
+
+export function artifactMime(path: string) {
+  return mimes.get(artifactExtension(path))
+}
+
+export function artifactKind(path: string): ArtifactKind {
+  const mime = artifactMime(path)
+  if (!mime) return "text"
+  if (mime === "image/svg+xml") return "svg"
+  if (mime === "application/pdf") return "pdf"
+  if (mime === "text/html") return "html"
+  if (mime === "text/markdown") return "markdown"
+  if (mime === "text/vnd.mermaid") return "mermaid"
+  if (mime === "text/csv" || mime === "text/tab-separated-values") return "table"
+  if (mime.startsWith("image/")) return "image"
+  if (mime.startsWith("audio/")) return "audio"
+  if (mime.startsWith("font/")) return "font"
+  return "video"
+}
+
+/** Kinds whose bytes are kept as base64 so media elements can play them without a text round trip. */
+const binaryKinds = new Set<ArtifactKind>(["image", "audio", "video", "pdf", "font"])
+
+/** Text files never contain NUL; a NUL in the first 8 KiB marks an unknown binary. */
+function isBinaryBytes(bytes: Uint8Array) {
+  return bytes.subarray(0, 8192).includes(0)
+}
+
+export function bytesToBase64(bytes: Uint8Array) {
+  const parts: string[] = []
+  for (let index = 0; index < bytes.length; index += 0x8000) {
+    parts.push(String.fromCharCode(...bytes.subarray(index, index + 0x8000)))
+  }
+  return btoa(parts.join(""))
+}
+
+/** Media above this stays a placeholder: base64 encoding on the main thread and the LRU budget both suffer. */
+export const MAX_MEDIA_BYTES = 25 * 1024 * 1024
+
+export function fileContentFromBytes(path: string, bytes: Uint8Array): FileContent {
+  const kind = artifactKind(path)
+  const mimeType = artifactMime(path)
+  if (binaryKinds.has(kind)) {
+    if (bytes.length > MAX_MEDIA_BYTES) return { type: "binary", content: "", size: bytes.length }
+    return { type: "binary", content: bytesToBase64(bytes), encoding: "base64", mimeType }
+  }
+  // Unknown binaries keep no bytes: the viewer only shows a placeholder for them.
+  if (kind === "text" && isBinaryBytes(bytes)) return { type: "binary", content: "", size: bytes.length }
+  return { type: "text", content: new TextDecoder().decode(bytes), mimeType }
+}
+
+/** Approximate on-disk size of loaded content. */
+export function contentBytes(content: FileContent) {
+  if (content.size !== undefined) return content.size
+  if (content.encoding === "base64") {
+    const padding = content.content.endsWith("==") ? 2 : content.content.endsWith("=") ? 1 : 0
+    return Math.floor((content.content.length * 3) / 4) - padding
+  }
+  return new TextEncoder().encode(content.content).length
+}
+
+/**
+ * Parse RFC 4180 style delimited text. Quoted fields may contain the delimiter, newlines, and
+ * doubled quotes. Rows beyond `limit` are counted but not returned.
+ */
+export function parseDelimited(text: string, delimiter: string, limit = 1000) {
+  const rows: string[][] = []
+  let row: string[] = []
+  let field = ""
+  let quoted = false
+  let total = 0
+  const endRow = () => {
+    row.push(field)
+    field = ""
+    const blank = row.length === 1 && row[0] === ""
+    if (!blank) {
+      total++
+      if (rows.length < limit) rows.push(row)
+    }
+    row = []
+  }
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index]!
+    if (quoted) {
+      if (char !== '"') {
+        field += char
+        continue
+      }
+      if (text[index + 1] === '"') {
+        field += '"'
+        index++
+        continue
+      }
+      quoted = false
+      continue
+    }
+    if (char === '"' && field === "") {
+      quoted = true
+      continue
+    }
+    if (char === delimiter) {
+      row.push(field)
+      field = ""
+      continue
+    }
+    if (char === "\r") continue
+    if (char === "\n") {
+      endRow()
+      continue
+    }
+    field += char
+  }
+  if (field !== "" || row.length > 0) endRow()
+  const columns = rows.reduce((max, current) => Math.max(max, current.length), 0)
+  return { rows, total, columns }
+}
+
+/** Build a blob URL from loaded content. Callers revoke it when the viewer unmounts. */
+export function blobUrlFromContent(content: FileContent) {
+  const type = content.mimeType ?? "application/octet-stream"
+  if (content.encoding !== "base64") return URL.createObjectURL(new Blob([content.content], { type }))
+  const raw = atob(content.content)
+  const bytes = Uint8Array.from(raw, (char) => char.charCodeAt(0))
+  return URL.createObjectURL(new Blob([bytes], { type }))
+}
+
+/**
+ * Resolve a relative link against a directory. A relative base yields a workspace-relative path and
+ * an absolute base an absolute one; undefined when the link climbs past the base's root.
+ */
+export function resolveArtifactPath(base: string, href: string) {
+  const target = href.replaceAll("\\", "/")
+  if (target.startsWith("/")) return undefined
+  const dir = base.replaceAll("\\", "/")
+  const segments = [...dir.split("/").filter(Boolean)]
+  for (const segment of target.split("/")) {
+    if (!segment || segment === ".") continue
+    if (segment !== "..") {
+      segments.push(segment)
+      continue
+    }
+    if (segments.length === 0) return undefined
+    segments.pop()
+  }
+  return `${dir.startsWith("/") ? "/" : ""}${segments.join("/")}`
+}
@@ -5,11 +5,12 @@ import { createSimpleContext } from "@opencode/ui/context"
 import { showToast } from "@/shell/notifications/toast"
 import { useParams } from "@solidjs/router"
 import { base64Encode } from "@opencode/util/encode"
-import { getFilename } from "@opencode/util/path"
+import { getDirectory, getFilename } from "@opencode/util/path"
 import { useWorkspaceLocation } from "@/workspaces/location"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useLayout } from "@/shell/state/layout"
 import { createPathHelpers } from "./path"
+import { fileContentFromBytes } from "./artifact"
 import {
  approxBytes,
  evictContentLru,
@@ -185,14 +186,17 @@ export const { use: useFile, provider: FileProvider } = createSimpleContext({

      setLoading(file)

+      // Files outside the workspace are read from their own directory, like markdown images.
+      // The trailing separator from getDirectory keeps "/" and "C:/" valid, like readLocalImage.
+      const request = path.absolute(file)
+        ? { path: getFilename(file), location: { directory: getDirectory(file) } }
+        : { path: file, location: { directory } }
      const promise = serverSDK.api.file
-        .read({ path: file, location: { directory } })
+        .read(request)
        .then((data) => {
          if (scope() !== directory) return
-          const content = { type: "text" as const, content: new TextDecoder().decode(data) }
+          const content = fileContentFromBytes(file, data)
          setLoaded(file, content)
-
-          if (!content) return
          touchFileContent(file, approxBytes(content))
          evictContent(new Set([file]))
        })
@@ -281,6 +285,7 @@ export const { use: useFile, provider: FileProvider } = createSimpleContext({
    return {
      ready: () => view().ready(),
      normalize: path.normalize,
+      absolute: path.absolute,
      tab: path.tab,
      pathFromTab: path.pathFromTab,
      tree: {
@@ -21,6 +21,24 @@ describe("file path helpers", () => {
    expect(path.normalize("c:\\repo\\src\\app.ts")).toBe("src\\app.ts")
  })

+  test("keeps files outside the workspace absolute and round-trips them through tabs", () => {
+    const posix = createPathHelpers(() => "/repo")
+    expect(posix.normalize("/tmp/out/report.pdf")).toBe("/tmp/out/report.pdf")
+    expect(posix.absolute("/tmp/out/report.pdf")).toBe(true)
+    expect(posix.absolute("src/app.ts")).toBe(false)
+    expect(posix.tab("/tmp/out/report.pdf")).toBe("file:///tmp/out/report.pdf")
+    expect(posix.pathFromTab("file:///tmp/out/report.pdf")).toBe("/tmp/out/report.pdf")
+    expect(posix.normalize("/repository/x.ts")).toBe("/repository/x.ts")
+
+    const windows = createPathHelpers(() => "C:\\repo")
+    expect(windows.normalize("C:\\tmp\\font.ttf")).toBe("C:\\tmp\\font.ttf")
+    expect(windows.normalize("file:///C:/tmp/font.ttf")).toBe("C:/tmp/font.ttf")
+    expect(windows.absolute("C:/tmp/font.ttf")).toBe(true)
+    expect(windows.tab("C:/tmp/font.ttf")).toBe("file:///C:/tmp/font.ttf")
+    expect(windows.pathFromTab("file:///C:/tmp/font.ttf")).toBe("C:/tmp/font.ttf")
+    expect(windows.pathFromTab("file:///C:/repo/src/app.ts")).toBe("src/app.ts")
+  })
+
  test("normalizes Windows directory separators", () => {
    const path = createPathHelpers(() => "C:\\repo")
    expect(path.normalizeDir("frontend\\")).toBe("frontend")
@@ -105,7 +105,11 @@ export function createPathHelpers(scope: () => string) {
  const normalize = (input: string) => {
    const root = scope()

-    let path = unquoteGitPath(decodeFilePath(stripQueryAndHash(stripFileProtocol(input))))
+    // file:///C:/dir becomes /C:/dir once the protocol is gone; restore the drive form.
+    let path = unquoteGitPath(decodeFilePath(stripQueryAndHash(stripFileProtocol(input)))).replace(
+      /^[/\\]([A-Za-z]:)/,
+      "$1",
+    )

    // Separator-agnostic prefix stripping for Cygwin/native Windows compatibility
    // Only case-insensitive on Windows (drive letter or UNC paths)
@@ -116,20 +120,21 @@ export function createPathHelpers(scope: () => string) {
      canonPath.startsWith(canonRoot) &&
      (canonRoot.endsWith("/") || canonPath === canonRoot || canonPath[canonRoot.length] === "/")
    ) {
-      // Slice from original path to preserve native separators
-      path = path.slice(root.length)
+      // Slice from original path to preserve native separators, then drop the separator itself.
+      path = path.slice(root.length).replace(/^[/\\]/, "")
    }

    if (path.startsWith("./") || path.startsWith(".\\")) {
      path = path.slice(2)
    }

-    if (path.startsWith("/") || path.startsWith("\\")) {
-      path = path.slice(1)
-    }
+    // An absolute path that is not under the root stays absolute; it is a file outside the workspace.
    return path
  }

+  /** Whether a normalized path points outside the workspace root. */
+  const absolute = (path: string) => /^[A-Za-z]:[/\\]/.test(path) || path.startsWith("/") || path.startsWith("\\\\")
+
  const tab = (input: string) => {
    const path = normalize(input)
    return `file://${encodeFilePath(path)}`
@@ -149,6 +154,7 @@ export function createPathHelpers(scope: () => string) {

  return {
    normalize,
+    absolute,
    tab,
    pathFromTab,
    normalizeDir,
@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs"
+import { createRequire } from "node:module"
 import solidPlugin from "vite-plugin-solid"
 import tailwindcss from "@tailwindcss/vite"
 import { fileURLToPath } from "url"
@@ -17,6 +18,24 @@ if (tailwindGenerate && typeof tailwindHotUpdate === "function") {
  }
 }

+// The markdown worker imports these directly, so they are served unbundled to keep worker startup
+// stable. Vite applies `exclude` to every import inside a pre-bundle too, which would leave a bare
+// `import "marked"` in mermaid's chunk that the browser cannot resolve from this package.
+const workerDeps = ["@shikijs/stream", "marked", "marked-shiki", "remend"]
+
+/** @type {import("rolldown").Plugin} */
+const bundleNestedWorkerDeps = {
+  name: "opencode-desktop:bundle-nested-worker-deps",
+  resolveId(id, importer) {
+    if (!importer || !workerDeps.includes(id) || !importer.includes("node_modules")) return
+    try {
+      return createRequire(importer).resolve(id)
+    } catch {
+      return
+    }
+  },
+}
+
 export const channel = (() => {
  const raw = process.env.OPENCODE_CHANNEL
  if (raw === "local" || raw === "dev" || raw === "beta" || raw === "prod") return raw
@@ -44,8 +63,9 @@ export default [
          format: "es",
        },
        optimizeDeps: {
-          exclude: ["@shikijs/stream", "marked", "marked-shiki", "remend"],
+          exclude: workerDeps,
          include: ["@opencode/session-ui > mermaid", "@opencode/session-ui > mermaid > katex"],
+          rolldownOptions: { plugins: [bundleNestedWorkerDeps] },
        },
      }
    },
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/cli",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "type": "module",
  "license": "MIT",
  "bin": {
@@ -5,34 +5,77 @@ import { Runtime } from "../../framework/runtime"
 import { Updater } from "../../services/updater"
 import { handlePromptErrors } from "../../ui/prompt"
 import { OPENCODE_VERSION } from "../../version"
+import { stripVTControlCharacters } from "node:util"

 export default Runtime.handler(
  Commands.commands.upgrade,
-  Effect.fn("cli.upgrade")(function* (input) {
-    intro("Upgrade")
-    const updater = yield* Updater.Service
-    const method = Option.getOrUndefined(input.method) ?? (yield* updater.method())
-    if (!method)
-      return yield* Effect.fail(
-        new Error("Could not detect the installation method. Pass --method to choose how to upgrade OpenCode."),
+  Effect.fn("cli.upgrade")(
+    function* (input) {
+      intro("Upgrade")
+      const updater = yield* Updater.Service
+      const method = Option.getOrUndefined(input.method) ?? (yield* updater.method())
+      if (!method)
+        return yield* Effect.fail(
+          new Error("Could not detect the installation method. Pass --method to choose how to upgrade OpenCode."),
+        )
+
+      log.info(`Using method: ${method}`)
+      const target = Option.getOrUndefined(input.target) ?? (yield* updater.latest())
+      const version = target.trim().replace(/^v/, "")
+      if (version === OPENCODE_VERSION) {
+        log.warn(`OpenCode upgrade skipped: ${version} is already installed`)
+        outro("Done")
+        return
+      }
+
+      log.info(`From ${OPENCODE_VERSION} → ${version}`)
+      const progress = spinner()
+      progress.start("Upgrading...")
+      yield* updater.upgrade(method, target).pipe(
+        Effect.tap(() => Effect.sync(() => progress.stop("Upgrade complete"))),
+        Effect.tapCause(() => Effect.sync(() => progress.stop("Upgrade failed", 1))),
      )
-
-    log.info(`Using method: ${method}`)
-    const target = Option.getOrUndefined(input.target) ?? (yield* updater.latest())
-    const version = target.trim().replace(/^v/, "")
-    if (version === OPENCODE_VERSION) {
-      log.warn(`OpenCode upgrade skipped: ${version} is already installed`)
      outro("Done")
-      return
-    }
-
-    log.info(`From ${OPENCODE_VERSION} → ${version}`)
-    const progress = spinner()
-    progress.start("Upgrading...")
-    yield* updater.upgrade(method, target).pipe(
-      Effect.tap(() => Effect.sync(() => progress.stop("Upgrade complete"))),
-      Effect.tapCause(() => Effect.sync(() => progress.stop("Upgrade failed", 1))),
-    )
-    outro("Done")
-  }, handlePromptErrors),
+    },
+    (effect) =>
+      handlePromptErrors(
+        effect.pipe(
+          Effect.mapError((error) =>
+            error instanceof Updater.UpgradeError ? new Error(formatUpgradeError(error), { cause: error }) : error,
+          ),
+        ),
+      ),
+  ),
 )
+
+function formatUpgradeError(error: Updater.UpgradeError) {
+  const clean = (value: string) => stripVTControlCharacters(value).replaceAll("\r", "").trim()
+  const line = (value: string) => clean(value).replace(/\s+/g, " ")
+  const detail = wrap(clean(error.detail), Math.max(24, (process.stdout.columns ?? 80) - 7)).join("\n")
+  return [
+    line(error.title),
+    "",
+    detail,
+    ...(error.command ? ["", field("Command", line(error.command))] : []),
+    field("Retry", line(error.retry)),
+  ].join("\n")
+}
+
+function field(label: string, value: string) {
+  const prefix = label.padEnd(9)
+  const width = Math.max(24, Math.min(61, (process.stdout.columns ?? 80) - prefix.length - 10))
+  const lines = wrap(value, width)
+  return lines.map((line, index) => `${index === 0 ? prefix : " ".repeat(prefix.length)}${line}`).join("\n")
+}
+
+function wrap(value: string, width: number) {
+  return value.split("\n").flatMap((source) => {
+    if (source.length <= width) return [source]
+    return source.split(/\s+/).reduce<string[]>((result, word) => {
+      const index = result.length - 1
+      if (index < 0 || result[index].length + word.length + 1 > width) result.push(word)
+      else result[index] += ` ${word}`
+      return result
+    }, [])
+  })
+}
@@ -1,7 +1,8 @@
 #!/usr/bin/env bun

 import { NodeRuntime, NodeServices } from "@effect/platform-node"
-import { Effect } from "effect"
+import { Cause, Effect } from "effect"
+import { getErrorReported } from "effect/Runtime"
 import { Commands } from "./commands/commands"
 import { Runtime } from "./framework/runtime"
 import { Observability } from "@opencode/util/observability"
@@ -130,5 +131,15 @@ Effect.gen(function* () {
  Effect.provide(NodeServices.layer),
  Effect.scoped,
  Effect.tap(() => Effect.sync(() => process.exit(process.exitCode ?? 0))),
-  NodeRuntime.runMain,
+  // runMain's default reporter logs the fatal cause to stdout. Write it to stderr instead: the
+  // desktop and `Service.ensure` only capture stderr from `serve --service`, so this is the only
+  // channel through which a startup failure's reason reaches the user.
+  Effect.tapCause((cause) =>
+    Effect.sync(() => {
+      if (Cause.hasInterruptsOnly(cause)) return
+      if (!getErrorReported(Cause.squash(cause))) return
+      process.stderr.write(Cause.pretty(cause) + "\n")
+    }),
+  ),
+  NodeRuntime.runMain({ disableErrorReporting: true }),
 )
@@ -5,7 +5,9 @@ import { Context, Duration, Effect, FileSystem, Layer, Option, Ref, Schema } fro
 import { ChildProcess } from "effect/unstable/process"
 import { parse, type ParseError } from "jsonc-parser"
 import path from "node:path"
+import { stripVTControlCharacters } from "node:util"
 import { action, parseReleaseVersion, type Policy } from "./updater-action"
+import { errorMessage } from "../util/error"

 export const methods = ["curl", "npm", "pnpm", "bun", "yarn", "vp", "brew"] as const

@@ -13,10 +15,82 @@ export type Method = (typeof methods)[number]
 export type RunResult = { readonly type: "available" | "installed"; readonly version: string }
 export type CheckResult = RunResult | { readonly type: "unavailable"; readonly message: string }

+export class UpgradeError extends Error {
+  readonly title: string
+  readonly detail: string
+  readonly command?: string
+  readonly retry: string
+
+  constructor(
+    input: {
+      readonly title: string
+      readonly detail: string
+      readonly command?: string
+      readonly retry: string
+    },
+    options?: ErrorOptions,
+  ) {
+    super(input.detail, options)
+    this.name = "UpgradeError"
+    this.title = input.title
+    this.detail = input.detail
+    this.command = input.command
+    this.retry = input.retry
+  }
+}
+
 const decodeVpPackages = Schema.decodeUnknownOption(
  Schema.fromJsonString(Schema.Array(Schema.Struct({ name: Schema.String }))),
 )

+const installNames: Record<Method, string> = {
+  curl: "The OpenCode installer",
+  npm: "npm",
+  pnpm: "pnpm",
+  bun: "Bun",
+  yarn: "Yarn",
+  vp: "Vite+",
+  brew: "Homebrew",
+}
+
+function conciseDetail(input: string) {
+  const lines = stripVTControlCharacters(input)
+    .trim()
+    .replaceAll("\r", "\n")
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .filter((line) => line.trim().length > 0)
+  const tail = lines.slice(-12).join("\n")
+  const clipped = tail.length > 2_000
+  const detail = clipped ? `…${tail.slice(-1_999)}` : tail
+  if (!detail) return
+  if (lines.length <= 12 && !clipped) return detail
+  return `${detail}\n\nOutput shortened to the last 12 lines.`
+}
+
+function errorDetail(cause: unknown): string {
+  if (cause instanceof AppProcess.AppProcessError) {
+    const stderr = conciseDetail(cause.stderr ?? "")
+    if (stderr) return stderr
+    if (cause.cause !== undefined) return errorDetail(cause.cause)
+    return cause.message
+  }
+  if (cause instanceof Error) {
+    const detail = cause.cause === undefined ? undefined : errorDetail(cause.cause)
+    if (!detail || detail === cause.message) return cause.message
+    return `${cause.message}: ${detail}`
+  }
+  return errorMessage(cause)
+}
+
+function resultDetail(result: { code: number; stdout: string; stderr: string }) {
+  return (
+    conciseDetail(result.stderr) ??
+    conciseDetail(result.stdout) ??
+    `The command exited with code ${result.code} without any error output.`
+  )
+}
+
 export interface Interface {
  readonly run: (onInstall?: (version: string) => void) => Effect.Effect<RunResult | undefined>
  readonly check: () => Effect.Effect<CheckResult | undefined, Error>
@@ -24,9 +98,9 @@ export interface Interface {
  readonly method: () => Effect.Effect<Method | undefined>
  readonly latest: () => Effect.Effect<string, Error>
  readonly upgrade: (method: Method, version: string) => Effect.Effect<void, Error>
-  readonly removal: (method: Method) =>
-    | { readonly command: ReadonlyArray<string>; readonly run: Effect.Effect<void, Error> }
-    | undefined
+  readonly removal: (
+    method: Method,
+  ) => { readonly command: ReadonlyArray<string>; readonly run: Effect.Effect<void, Error> } | undefined
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/cli/Updater") {}
@@ -89,7 +163,6 @@ const make = Effect.gen(function* () {
          stdout: result.stdout.toString("utf8"),
          stderr: result.stderr.toString("utf8"),
        })),
-        Effect.orElseSucceed(() => ({ code: 1, stdout: "", stderr: "" })),
      )
  })

@@ -119,7 +192,11 @@ const make = Effect.gen(function* () {
    ]
    const results = yield* Effect.forEach(
      checks,
-      (check) => exec(check.command).pipe(Effect.map((result) => ({ check, result }))),
+      (check) =>
+        exec(check.command).pipe(
+          Effect.orElseSucceed(() => ({ code: 1, stdout: "", stderr: "" })),
+          Effect.map((result) => ({ check, result })),
+        ),
      { concurrency: "unbounded" },
    )
    return results.find((result) => {
@@ -144,11 +221,7 @@ const make = Effect.gen(function* () {
    return {
      command,
      run: exec(command, "5 minutes").pipe(
-        Effect.flatMap((result) =>
-          result.code === 0
-            ? Effect.void
-            : Effect.fail(new Error(result.stderr.trim() || `Failed to uninstall with ${method}`)),
-        ),
+        Effect.flatMap((result) => (result.code === 0 ? Effect.void : Effect.fail(new Error(resultDetail(result))))),
      ),
    }
  }
@@ -163,14 +236,44 @@ const make = Effect.gen(function* () {
            signal: AbortSignal.any([signal, AbortSignal.timeout(10_000)]),
          },
        ),
-      catch: (cause) => new Error("Failed to check for updates", { cause }),
+      catch: (cause) =>
+        new UpgradeError(
+          {
+            title: "Could not check for OpenCode updates",
+            detail: errorDetail(cause),
+            retry: "Check your network, then run opencode upgrade again.",
+          },
+          { cause },
+        ),
    })
-    if (!response.ok) return yield* Effect.fail(new Error(`Update check failed with status ${response.status}`))
+    if (!response.ok)
+      return yield* Effect.fail(
+        new UpgradeError({
+          title: "Could not check for OpenCode updates",
+          detail: `The update service returned HTTP ${response.status}.`,
+          retry: "Try again in a few minutes.",
+        }),
+      )
    const data: { version: string; metadata?: { package?: string } } = yield* Effect.tryPromise({
      try: () => response.json(),
-      catch: (cause) => new Error("Failed to read update information", { cause }),
+      catch: (cause) =>
+        new UpgradeError(
+          {
+            title: "Could not read the OpenCode update information",
+            detail: errorDetail(cause),
+            retry: "Try again in a few minutes.",
+          },
+          { cause },
+        ),
    })
-    if (!data.metadata?.package) return yield* Effect.fail(new Error("Update information did not include a package"))
+    if (!data.metadata?.package)
+      return yield* Effect.fail(
+        new UpgradeError({
+          title: "Could not read the OpenCode update information",
+          detail: "The update service returned incomplete release information.",
+          retry: "Try again in a few minutes.",
+        }),
+      )
    return { package: data.metadata.package, version: data.version }
  })

@@ -185,6 +288,40 @@ const make = Effect.gen(function* () {
      fs.remove(directory, { recursive: true, force: true }).pipe(Effect.ignore),
    )

+  const runUpgrade = (input: {
+    readonly method: Method
+    readonly command: string[]
+    readonly displayCommand?: string[]
+    readonly title?: string
+    readonly retry?: string
+  }) => {
+    const failure = (detail: string, cause?: unknown) =>
+      new UpgradeError(
+        {
+          title: input.title ?? `${installNames[input.method]} could not install OpenCode`,
+          detail,
+          command: (input.displayCommand ?? input.command).join(" "),
+          retry: input.retry ?? "Fix the issue above, then run opencode upgrade again.",
+        },
+        cause === undefined ? undefined : { cause },
+      )
+    return exec(input.command, "5 minutes").pipe(
+      Effect.flatMap((result) =>
+        result.code === 0 ? Effect.succeed(result) : Effect.fail(failure(resultDetail(result))),
+      ),
+      Effect.mapError((cause) =>
+        cause instanceof UpgradeError
+          ? cause
+          : failure(
+              cause instanceof AppProcess.AppProcessError && cause.stderr === undefined && cause.cause === undefined
+                ? `Failed to update with ${input.method}`
+                : errorDetail(cause),
+              cause,
+            ),
+      ),
+    )
+  }
+
  const upgrade = Effect.fnUntraced(function* (method: Method, input: string) {
    if (!parseReleaseVersion(input)) return yield* Effect.fail(new Error(`Invalid version: ${input}`))
    const version = input.trim().replace(/^v/, "")
@@ -212,31 +349,54 @@ const make = Effect.gen(function* () {
          ? ["vp", "install", "-g", "--force", target]
          : ["vp", "update", "-g", target],
    }
-    const result = yield* Effect.scoped(
+    yield* Effect.scoped(
      Effect.gen(function* () {
        if (method === "bun") {
          // Bun does not prune old versions from its shared package cache.
          yield* fs.makeDirectory(global.cache, { recursive: true })
          const cache = yield* temporaryDirectory("update-")
-          return yield* exec(["bun", "install", "--global", "--trust", "--cache-dir", cache, target], "5 minutes")
+          return yield* runUpgrade({
+            method,
+            command: ["bun", "install", "--global", "--trust", "--cache-dir", cache, target],
+            displayCommand: ["bun", "install", "--global", "--trust", target],
+          })
        }
        if (method === "curl") {
          yield* fs.makeDirectory(global.cache, { recursive: true })
          const directory = yield* temporaryDirectory("update-")
          const installer = path.join(directory, "install")
-          const download = yield* exec(
-            ["curl", "-fsSL", "-o", installer, "https://opencode.ai/v2/install"],
-            "5 minutes",
-          )
-          if (download.code !== 0) return download
-          return yield* exec(["bash", installer, "--version", version, "--no-modify-path"], "5 minutes")
+          yield* runUpgrade({
+            method,
+            command: ["curl", "-fsSL", "-o", installer, "https://opencode.ai/v2/install"],
+            displayCommand: ["curl", "-fsSL", "https://opencode.ai/v2/install"],
+            title: "Could not download the OpenCode installer",
+            retry: "Check your network, then run opencode upgrade again.",
+          })
+          return yield* runUpgrade({
+            method,
+            command: ["bash", installer, "--version", version, "--no-modify-path"],
+            displayCommand: ["opencode", "upgrade", version, "--method", "curl"],
+            title: "The OpenCode installer failed",
+          })
        }
-        if (method === "brew") return yield* exec(["brew", "upgrade", packageName], "5 minutes")
-        return yield* exec(commands[method], "5 minutes")
+        if (method === "brew") return yield* runUpgrade({ method, command: ["brew", "upgrade", packageName] })
+        return yield* runUpgrade({ method, command: commands[method] })
      }),
-    ).pipe(Effect.mapError((cause) => new Error(`Failed to update with ${method}`, { cause })))
-    if (result.code === 0) return
-    return yield* Effect.fail(new Error(result.stderr.trim() || `Failed to update with ${method}`))
+    ).pipe(
+      Effect.mapError((cause) =>
+        cause instanceof UpgradeError
+          ? cause
+          : new UpgradeError(
+              {
+                title: "Could not prepare the OpenCode upgrade",
+                detail: errorDetail(cause),
+                retry: "Fix the issue above, then run opencode upgrade again.",
+              },
+              { cause },
+            ),
+      ),
+      Effect.asVoid,
+    )
  })

  const inspect = Effect.fnUntraced(function* () {
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/client",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "type": "module",
  "license": "MIT",
  "repository": {
@@ -6,6 +6,8 @@
 - Tool schemas are the model-facing Interface. Keep arguments minimal and natural to the operation; never add unrelated IDs as ambient capability tokens.
 - State model-visible diagnostics, logs, tool descriptions, and instructions directly. The execution context is already clear; do not repeat `Code Mode` or `CodeMode` unless the distinction is necessary.
 - When interpreter behavior or support changes, update `interpreter-support.md` and direct tests in the same PR.
+- Program values are `Value` (`src/interpreter/objects.ts`); host values are `unknown` and are copied in at the boundaries (`fromHost`, `fromJson`). Do not widen program-facing signatures back to `unknown`.
+- A built-in kind of object is one `Obj` subclass (`Wrapper` for host-backed data such as Date or Map, `Opaque` for machinery such as functions and promises) that overrides `tag`, `toString`, `toPrimitive`, `inspect`, `toHost`, and `iterator` as needed. Do not add `instanceof` ladders over the built-in classes elsewhere; ask the object.

 ## OpenAPI

@@ -24,7 +24,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      and Map, RegExp, and generators serialize as `{}`. A bare `undefined` result is `null`.
      Tool results come back the way `JSON.parse(JSON.stringify(result))` would. The table, where a value cannot
      be JSON but what the program meant is clear: a promise is awaited (a rejection fails the program), a Set
-      crosses as an array, a URLSearchParams as its query string, an Error as `{ name, message, ...own }`, a
+      crosses as an array, a URLSearchParams as its query string, an Error as `{ name, message, ...own enumerable }`, a
      Uint8Array is rejected with a hint to encode as text, and own `__proto__` keys are dropped so merging tool
      inputs or results cannot replace a prototype. In-program `JSON.stringify` keeps JS behavior except for the
      Error form and a promise, which is a `TypeError` with an await hint rather than a silent `{}`.
@@ -38,8 +38,11 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      10,000,000 elements (`Array(n)`, `length =`, `Array.from`, `split`, `matchAll`, `concat`, `flat`; below the JS
      maximum of 2^32 - 1), and 10,000 pending promises at once. Exceeding one throws a `RangeError`. A single regular
      expression match can still run long on a pathological pattern; the host regex engine has no interrupt hook.
- [ ] Strict-mode early errors: duplicate parameter names, `yield` as an identifier, and a trailing comma after a
-      rest parameter are accepted unless the program itself begins with `"use strict"`.
+- [x] A trailing comma after a rest parameter is a syntax error, with or without `"use strict"`.
+- [x] A program that begins with `"use strict"` rejects `yield` as an identifier and duplicate parameter names at
+      parse time. Without it, `yield` is an ordinary binding.
+- [ ] Duplicate parameter names in non-strict code throw when the function is called, instead of binding the last
+      parameter as JavaScript does.

 ## Values and literals

@@ -84,7 +87,6 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Destructuring reads through the prototype chain like member access: `const { constructor } = error` and
      `const { slice } = values` find the inherited built-in.
 - [ ] Member expressions as `for...in` targets (`for (x.y in obj)`).
- [ ] `IteratorClose` during destructuring should throw a `TypeError` when `return()` yields a non-object.

 ## Statements and control flow

@@ -94,7 +96,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] `for`, `while`, and `do...while`.
 - [x] `for...of` over arrays, strings, Maps, Sets, URLSearchParams, Headers, Uint8Arrays, built-in iterators, custom
      synchronous iterators, and confined synchronous generators. Abrupt completion invokes the iterator's optional `return()`.
- [x] `for...in` over own keys of plain objects, arrays, strings, and tool references; other values iterate nothing.
+- [x] `for...in` over own keys of plain objects, arrays, strings, and tool references. `null`, `undefined`, and other
+      non-objects iterate nothing. An un-awaited promise throws rather than iterating.
 - [x] Unlabeled `break` and `continue`.
 - [x] `try`, `catch`, optional catch bindings, and `finally`.
 - [x] `throw` with arbitrary values.
@@ -108,7 +111,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 ## Functions and callbacks

 - [x] Function declarations, function expressions, and arrow functions.
- [x] Synchronous and `async` functions.
+- [x] Synchronous and `async` functions. A line break between `function` and the name is allowed, as in JavaScript;
+      a line break between `async` and `function` is not an async function.
 - [x] Closures, recursion, default parameters, rest parameters, and destructured parameters.
 - [x] A call depth limit of 10000: deeper nesting throws a catchable `RangeError: Maximum call stack size exceeded`
      at the overflowing call instead of running until the timeout. Callbacks invoked by built-ins count below the
@@ -143,7 +147,6 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      `Array.prototype.push.name === "push"`).
 - [ ] A named function expression's name is not bound inside its own body.
 - [ ] Redeclaring a function in the same scope is rejected; in JavaScript the last declaration wins.
- [ ] A line terminator between `async function` and the function name.
 - [ ] Generator and async generator functions evaluate parameter defaults and destructuring at the first `next()`
      rather than at the call, so their errors are not thrown synchronously.
 - [x] Synchronous and async generator declarations/expressions, `yield`, and `yield*`, including lazy bodies,
@@ -158,7 +161,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      rejected by every synchronous consumer.
 - [x] Synchronous iterator acquisition and result validation follow `IteratorClose` boundaries: consumer errors and
      intentional early stops invoke `return()`, acquisition/`next()` failures do not, and an original consumer error
-      wins over a cleanup failure. Async iterator consumption remains limited to `for await...of` and async `yield*`.
+      wins over a cleanup failure. A generator's `return()` is an intentional stop, so a `return()` that throws or
+      yields a non-object surfaces from it as a `TypeError`. Async iterator consumption remains limited to `for await...of` and async `yield*`.
 - [x] Portable generator protocol coverage is adapted from pinned Test262 cases for suspended-start, suspended-yield,
      and completed states; sync and async `next`/`return`/`throw`; finally yields and completion overrides; rejected
      yielded promises; mixed async request queues; sync and async `yield*` forwarding; malformed methods/results;
@@ -180,7 +184,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      on any other value throws a catchable `TypeError` naming the callee: other built-in functions such as `Number`
      say `new` is unsupported and point at the plain call, user-defined functions report the constructor gap below,
      and non-callable values are not constructors. Error constructors take the ES2022 options object, so
-      `new Error(message, { cause })` installs a non-enumerable `cause` when the option is present.
+      `new Error(message, { cause })` installs a non-enumerable `cause` when the option is present. `Error.isError`
+      is true for every Error value.
 - [x] Arithmetic operators: `+`, `-`, `*`, `/`, `%`, and `**`.
 - [x] Equality and ordering: `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, and `>=`.
 - [x] Bitwise operators: `&`, `|`, `^`, `~`, `<<`, `>>`, and `>>>`.
@@ -233,6 +238,10 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      resolving with the promise itself rejects with a `TypeError`. Resolver callables work anywhere callbacks are
      accepted, including `.then`/`.catch` handlers and collection callbacks, and vanish at the data boundary like
      any function.
+- [x] `Promise.withResolvers()`: the same promise and resolver callables as the constructor, as a `{ promise, resolve,
+    reject }` object.
+- [x] `Promise.try(fn, ...args)`: calls `fn` synchronously; a throw rejects, a return fulfils, and a returned promise or
+      thenable is adopted.
 - [x] Recursive assimilation of objects with an own callable `then` field across `Promise.resolve`, combinators,
      constructors, reactions, `finally`, `await`, and async returns. Thenable methods run deferred, receive
      first-call-wins resolve/reject functions, and ignore throws after settlement. Inherited/accessor `then` fields
@@ -270,8 +279,9 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] `Object.is` for supported data values.
 - [x] `Object.groupBy` over finite collections and custom synchronous iterators/generators, with string-key coercion
      and plain-object results.
- [x] `Object.prototype` methods on values: `toString` (`"[object Array]"`), `toLocaleString`, `valueOf`,
-      `hasOwnProperty`, `isPrototypeOf`, and `propertyIsEnumerable`.
+- [x] `Object.prototype` methods on values: `toString` (`"[object Array]"`, `"[object Map]"`, `"[object Promise]"`, and so
+      on for every built-in kind, as JS reports through `Symbol.toStringTag`), `toLocaleString` (calls the value's
+      `toString`, as in JS), `valueOf`, `hasOwnProperty`, `isPrototypeOf`, and `propertyIsEnumerable`.

 ## Arrays

@@ -285,12 +295,14 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      `lastIndexOf`.
 - [x] Aggregation: `reduce` and `reduceRight`.
 - [x] Ordering: `sort`, `toSorted`, `reverse`, and `toReversed`.
- [x] Access/copying: `at`, `slice`, `concat`, `flat`, `with`, and `join`.
+- [x] Access/copying: `at`, `slice`, `concat`, `flat`, `with`, `join`, and `toLocaleString` (each element's
+      `toLocaleString`, holes and nullish elements as empty strings).
 - [x] Mutation: `push`, `pop`, `shift`, `unshift`, `splice`, `fill`, and `copyWithin`.
 - [x] `keys`, `values`, `entries`, and `[Symbol.iterator]` (the same function as `values`) return live iterator objects
      with `next()` and `[Symbol.iterator]`, as in JS. Iterator objects are opaque references: they print as
      `[opaque reference]`, serialize to `{}`, and cannot be passed to extensions. Every built-in collection iterator
-      shares one prototype, which is only observable through `getPrototypeOf`.
+      shares one prototype. JavaScript gives each collection its own; the difference is not observable here because
+      `Object.getPrototypeOf` is not exposed.
 - [x] `length`, numeric indexing, index assignment, spread, and `for...of`.
 - [x] The `thisArg` argument of `Array.from` is accepted and ignored, like JS arrows.
 - [x] `Array.prototype.toSpliced`.
@@ -303,12 +315,13 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      form, like `JSON.stringify`.
 - [ ] Argument coercion for `indexOf`, `lastIndexOf`, `includes`, `fill`, `flat`, `copyWithin`, and the `join`
      separator: JavaScript applies ToIntegerOrInfinity/ToString (including `valueOf`, strings, and `undefined`), the
-      interpreter requires numbers and strings; `includes()`/`indexOf()` with no argument should search for
-      `undefined`.
+      interpreter requires numbers and strings. `indexOf()` and `lastIndexOf()` with no argument already search for
+      `undefined`; `includes()` still requires a value.

 ## Strings

- [x] Case/normalization: `toLowerCase`, `toUpperCase`, `normalize`.
+- [x] Case/normalization: `toLowerCase`, `toUpperCase`, `normalize`, and the `toLocaleLowerCase`/`toLocaleUpperCase`
+      aliases, which ignore their locale argument and apply the default Unicode casing.
 - [x] Trimming: `trim`, `trimStart`, and `trimEnd`, plus the Annex B `trimLeft` and `trimRight` aliases.
 - [x] Searching/tests: `includes`, `startsWith`, `endsWith`, `indexOf`, `lastIndexOf`, and `search`.
 - [x] Slicing/access: `slice`, `substring`, Annex B `substr`, `at`, `charAt`, `charCodeAt`, and `codePointAt`.
@@ -332,7 +345,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Coercion functions: `Number`, `parseInt`, and `parseFloat`.
 - [x] Number predicates/parsers: `Number.isInteger`, `Number.isFinite`, `Number.isNaN`, `Number.isSafeInteger`,
      `Number.parseInt`, and `Number.parseFloat`.
- [x] Number formatting: `toFixed`, `toPrecision`, `toExponential`, `toString`, and `valueOf`.
+- [x] Number formatting: `toFixed`, `toPrecision`, `toExponential`, `toString`, `valueOf`, and `toLocaleString`, which
+      always formats as `en-US` (`"1,234.5"`) so output does not depend on the host.
 - [x] Number constants: `MAX_SAFE_INTEGER`, `MIN_SAFE_INTEGER`, `MAX_VALUE`, `MIN_VALUE`, `EPSILON`, `NaN`,
      `POSITIVE_INFINITY`, and `NEGATIVE_INFINITY`.
 - [x] Math constants: `PI`, `E`, `LN2`, `LN10`, `LOG2E`, `LOG10E`, `SQRT2`, and `SQRT1_2`.
@@ -345,7 +359,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      use their epoch time) and reject opaque runtime references as data errors.
 - [x] Unknown static members on global namespaces and on `Number`/`String`/the coercion functions read as `undefined`
      for feature detection. Calling any undefined value reports a native-style `TypeError` naming the callee, for
-      example `Math.sum is not a function.` Unknown `Promise` statics keep their descriptive error.
+      example `Math.sum is not a function.` or `search(...).catch is not a function.` Unknown `Promise` statics keep
+      their descriptive error.
 - [x] `Math.sumPrecise` over finite collections and custom synchronous iterators/generators, rejecting non-number
      elements without coercion.
 - [x] Global coercing `isFinite` and `isNaN`; opaque runtime references reject as data errors, like `Number(...)`.
@@ -359,7 +374,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] `JSON.stringify` function and array replacers. Function replacers receive `(key, value)` in preorder, including
      the root, but no `this` holder. Array replacers preserve requested property order, deduplicate names, coerce
      number primitives, and ignore non-string/non-number entries. Primitive wrapper entries remain unsupported.
- [x] Captured `console.log`, `console.info`, `console.debug`, `console.warn`, and `console.error`.
+- [x] Captured `console.log`, `console.info`, `console.debug`, `console.warn`, and `console.error`. An Error prints as
+      `Error.prototype.toString` would show it (`Error: boom`), wherever it appears in the logged value.
 - [x] Captured `console.dir` and `console.table`.

 ## Date
@@ -379,6 +395,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      `TimeClip` behavior.
 - [x] `Date.prototype.toUTCString` and its `toGMTString` alias.
 - [x] `toDateString` and `toTimeString` in the host's local timezone.
+- [x] `toLocaleString`, `toLocaleDateString`, and `toLocaleTimeString` always format as `en-US` in UTC
+      (`"1/1/1970, 12:00:00 AM"`) so output does not depend on the host.
 - [x] Native one-argument Date coercion for supported values, including booleans, null, arrays, and plain objects.
 - [ ] Date setters and multi-argument construction coerce object arguments through `valueOf`/`toString` and surface
      their throws.
@@ -400,15 +418,29 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Match `indices` metadata for the `d` flag, including named groups on `exec`, `match`, and `matchAll` results.
 - [x] `RegExp.escape`.

+## Iterator
+
+- [x] `Iterator.prototype.map`, `filter`, `take`, `drop`, and `flatMap` on any iterator or generator: lazy, one source
+      step per result, closing the source when a callback throws, on early `return()`, or when `for...of` or
+      destructuring finishes with it early. Once done or closed a helper stays done, and a callback that re-enters its
+      own helper is a `TypeError`. `take`/`drop` coerce their count and reject `NaN` or negative counts with a
+      `RangeError`; `flatMap` callbacks must return an iterable or iterator, not a string.
+- [x] `Iterator.prototype.reduce`, `toArray`, `forEach`, `some`, `every`, and `find`, closing the source on early exit.
+- [x] `Iterator.from(value)` returns iterators and generators as they are, and wraps strings, iterables, and objects
+      with a `next` method. `Iterator` itself is abstract: calling or constructing it is a `TypeError`.
+- [x] Helpers and `Iterator.from` wrappers have `return()`; collection iterators (`array.values()`) do not, as in JS,
+      so an early exit from them leaves them where they were.
+- [ ] `Iterator.concat`, `Iterator.zip`, and `Iterator.zipKeyed` (stage 3 proposals).
+
 ## Map and Set

 - [x] Static `Map.groupBy` over finite collections and custom synchronous iterators/generators, preserving key identity.
 - [x] `new Map()` from synchronous iterables of entries.
- [x] Map `get`, `set`, `has`, `delete`, `clear`, `size`, and `forEach`.
+- [x] Map `get`, `set`, `has`, `delete`, `clear`, `size`, `forEach`, `getOrInsert`, and `getOrInsertComputed`.
 - [x] `new Set()` from synchronous iterables.
 - [x] Set `add`, `has`, `delete`, `clear`, `size`, and `forEach`.
 - [x] Live `keys`, `values`, `entries`, and `[Symbol.iterator]` iterators for Map and Set; a Set-like operand's `keys()`
-      may return a built-in iterator or an array.
+      may return any iterator or an array.
 - [x] Spread, `for...of`, `Array.from`, and `Object.fromEntries` integration.
 - [x] Map and Set values serialize to `{}` at host/JSON boundaries.
 - [x] Set composition and relation methods: `union`, `intersection`, `difference`, `symmetricDifference`, `isSubsetOf`,
@@ -425,7 +457,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] `new URLSearchParams()` from query strings, data objects, synchronous iterables of pairs, and URLSearchParams.
 - [x] URLSearchParams `append`, `delete`, `get`, `getAll`, `has`, `set`, `sort`, `forEach`, `keys`, `values`,
      `entries`, `[Symbol.iterator]`, `toString`, and `size`.
- [x] URL values serialize to their href; URLSearchParams serialize to `{}`.
+- [x] URL values are their href in `JSON.stringify` and at the host boundary. URLSearchParams are `{}` in
+      `JSON.stringify` and their query string at the host boundary.

 ## Uint8Array

@@ -470,7 +503,8 @@ Nothing is exposed unless a host provides it; extension calls are not tool calls
 - [x] Every value crossing in either direction is converted, never shared: plain objects and arrays are copied,
      `Date`, `RegExp`, `URL`, `URLSearchParams`, `Headers`, `Map`, `Set`, and `Uint8Array` become fresh copies with
      their contents converted (a host `ArrayBuffer` comes in as a `Uint8Array`; other typed arrays cannot come out),
-      errors cross as errors with their name and message, and a `__proto__` key is dropped. Functions, generators,
+      errors cross as errors with their name, message, `cause`, and own enumerable data, and a `__proto__` key is
+      dropped. Functions, generators,
      un-awaited promises, and symbols cannot be passed in; a class instance, a symbol, or a BigInt cannot come out.
 - [x] A host function inside a result becomes a program function whose calls cross the same way, so a result can
      carry methods (`res.json()`) whose host closures keep the host state. Diagnostics name it by its path
@@ -495,8 +529,10 @@ Nothing is exposed unless a host provides it; extension calls are not tool calls
 - [x] `AggregateError` with the `(errors, message?)` signature and an own `errors` array, constructed directly or by
      an all-rejected `Promise.any`; direct construction accepts custom synchronous iterators and generators.
 - [x] Error `name`/`message`, error inheritance through `instanceof`, and plain-data serialization. `message` is an own
-      non-enumerable property and `name` is inherited, as in JS, so `Object.keys(err)` is `[]` while the host still
-      receives `{ name, message }`. Errors have no `stack`; the diagnostic carries the source location instead.
+      non-enumerable property and `name` is inherited, as in JS, so `Object.keys(err)` is `[]` for a plain error. The
+      result boundary still emits `{ name, message, ...own enumerable }`, so a field such as `code` crosses. `cause` is
+      non-enumerable: an extension Error carries it, and this JSON form does not. Errors have no `stack`; the diagnostic
+      carries a 1-based line and column in the submitted source instead.
 - [x] `instanceof` against any constructor with a `prototype`, including every built-in and `Function`.
 - [x] Catchable user throws, runtime failures raised during interpreted evaluation, awaited tool failures, and awaited
      tool-call-limit failures; parse/compile failures, cooperative timeout, and output bounding remain outside program
@@ -505,8 +541,9 @@ Nothing is exposed unless a host provides it; extension calls are not tool calls
      short orientation to the supported subset; this matrix is the full reference.
 - [x] Model-visible host failure messages and underlying causes, including output-validation errors.
 - [x] Caught errors do not distinguish user throws, interpreter failures, and tool failures; a program sees one
-      Error-shaped value with `name` and `message` in `catch`, rejection handlers, and `Promise.allSettled` reasons.
-      This is deliberate: the program should handle a failure the same way regardless of where it originated.
+      Error-shaped value in `catch`, rejection handlers, and `Promise.allSettled` reasons. It always has `name` and
+      `message`, plus `cause` and own data when the failure carried them. This is deliberate: the program should
+      handle a failure the same way regardless of where it originated.
 - [x] Failures raised by the interpreter are `TypeError`s unless JavaScript names them otherwise (`RangeError`,
      `ReferenceError`, `SyntaxError`, `URIError`), so `e instanceof TypeError` and `e.constructor === TypeError`
      hold. Unsupported syntax reached at runtime is a `SyntaxError`; awaited tool failures stay plain `Error`.
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/codemode",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "description": "Effect-native confined code execution over schema-described tools",
  "type": "module",
  "license": "MIT",
@@ -15,6 +15,7 @@ import {
  Obj,
  PromiseObj,
  record,
+  type Value,
  SetObj,
  URLSearchParamsObj,
  HeadersObj,
@@ -23,14 +24,14 @@ import { typeofValue } from "./interpreter/references.js"

 export type Json = Schema.Json

-type Replacer<R> = (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>
+type Replacer<R> = (args: Array<Value>) => Effect.Effect<Value, unknown, R>

 /**
 * What `JSON.stringify` would serialize for a program value, as host JSON: `toJSON` is honored, functions and
 * `undefined` vanish, non-finite numbers become null, and everything else is copied. Two departures from JS
 * so a mistake is not a silent `{}`: an Error serializes as `{ name, message, ...own }`, and a promise throws.
 */
-export const toJson = <R>(ctx: Interpreter<R>, value: unknown, replacer?: Replacer<R>) =>
+export const toJson = <R>(ctx: Interpreter<R>, value: Value, replacer?: Replacer<R>) =>
  walk(ctx, value, replacer, false)

 /**
@@ -38,11 +39,11 @@ export const toJson = <R>(ctx: Interpreter<R>, value: unknown, replacer?: Replac
 * awaited, a Set crosses as an array, a URLSearchParams as its query string, a Uint8Array asks to be encoded as
 * text first, and a `__proto__` key is dropped so host code can never receive one.
 */
-export const toBoundary = <R>(ctx: Interpreter<R>, value: unknown) => walk(ctx, value, undefined, true)
+export const toBoundary = <R>(ctx: Interpreter<R>, value: Value) => walk(ctx, value, undefined, true)

 const walk = <R>(
  ctx: Interpreter<R>,
-  value: unknown,
+  value: Value,
  replacer: Replacer<R> | undefined,
  boundary: boolean,
 ): Effect.Effect<Json | undefined, unknown, R> => {
@@ -104,7 +105,7 @@ const walk = <R>(
 }

 /** Host JSON as program values: objects and arrays are copied, primitives pass through. */
-export const fromJson = <R>(ctx: Interpreter<R>, value: unknown): unknown => {
+export const fromJson = <R>(ctx: Interpreter<R>, value: Json | undefined): Value => {
  if (value === null || typeof value !== "object") return value
  if (Array.isArray(value))
    return new Arr(
@@ -1,24 +1,35 @@
-import { Effect, Exit } from "effect"
-import { coerceToNumber, coerceToString } from "../stdlib/value.js"
+import { Cause, Effect, Exit } from "effect"
 import type { Interpreter } from "./interpreter.js"
-import { typeError } from "./model.js"
-import { Callable, get, Native, DateObj, Obj } from "./objects.js"
+import { primitivePrototype } from "./intrinsics.js"
+import { GeneratorReturn, typeError } from "./model.js"
+import {
+  Callable,
+  get,
+  Native,
+  DateObj,
+  Obj,
+  coerceToNumber,
+  coerceToString,
+  type Cursor,
+  type Value,
+} from "./objects.js"
 import { typeofValue } from "./references.js"

-export type IteratorCursor<R> = {
-  readonly next: Effect.Effect<{ readonly done: boolean; readonly value: unknown }, unknown, R>
-  readonly close: Effect.Effect<void, unknown, R>
-}
-
+/** IteratorClose: a consumer failure closes the iterator and wins over any close failure, except that a generator's
+ * return() is a return completion, so a failing close wins over it, as after `break`. */
 export const preserveConsumerError = <A, R>(
-  cursor: IteratorCursor<R>,
+  close: Cursor<R>["close"],
  effect: Effect.Effect<A, unknown, R>,
 ): Effect.Effect<A, unknown, R> =>
-  Effect.flatMap(Effect.exit(effect), (exit) =>
-    Exit.isSuccess(exit)
-      ? Effect.succeed(exit.value)
-      : Effect.andThen(Effect.exit(cursor.close), Effect.failCause(exit.cause)),
-  )
+  Effect.flatMap(Effect.exit(effect), (exit) => {
+    if (Exit.isSuccess(exit)) return Effect.succeed(exit.value)
+    return Effect.flatMap(Effect.exit(close), (closed) => {
+      if (!Exit.isSuccess(closed) && Cause.squash(exit.cause) instanceof GeneratorReturn) {
+        return Effect.failCause(closed.cause)
+      }
+      return Effect.failCause(exit.cause)
+    })
+  })

 /**
 * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
@@ -26,9 +37,9 @@ export const preserveConsumerError = <A, R>(
 */
 export const toPrimitive = <R>(
  ctx: Interpreter<R>,
-  value: unknown,
+  value: Value,
  hint: "number" | "string" | "default",
-): Effect.Effect<unknown, unknown, R> => {
+): Effect.Effect<Value, unknown, R> => {
  if (!(value instanceof Obj)) return Effect.succeed(value)
  const asString = hint === "string" || (hint === "default" && value instanceof DateObj)
  const order = asString ? ["toString", "valueOf"] : ["valueOf", "toString"]
@@ -43,24 +54,31 @@ export const toPrimitive = <R>(
  })
 }

-export const toPrimitiveString = <R>(ctx: Interpreter<R>, value: unknown) =>
+/** Invoke(value, name): calls the method the value would find through its prototype. */
+export const invoke = <R>(ctx: Interpreter<R>, value: Value, name: string, label: string) => {
+  const target = value instanceof Obj ? value : primitivePrototype(ctx.builtins, value)
+  if (target === undefined) throw typeError(`${label} called on null or undefined.`)
+  return ctx.call(get(target, name), value, [])
+}
+
+export const toPrimitiveString = <R>(ctx: Interpreter<R>, value: Value) =>
  Effect.map(toPrimitive(ctx, value, "string"), coerceToString)

-export const toPrimitiveNumber = <R>(ctx: Interpreter<R>, value: unknown) =>
+export const toPrimitiveNumber = <R>(ctx: Interpreter<R>, value: Value) =>
  Effect.map(toPrimitive(ctx, value, "number"), coerceToNumber)

 // The single acceptance list for callbacks: collections, sort, string replacers,
 // Array.from mappers, and promise reactions all admit exactly these callables.
 // Admission means dispatchable, not necessarily invocable: new-requiring
 // constructors pass the gate and throw a TypeError on call, like JS.
-export const isSupportedCallback = (value: unknown): value is Callable =>
+export const isSupportedCallback = (value: Value): value is Callable =>
  value instanceof Callable && !(value instanceof Native && !value.callback)

 export const applyCollectionCallback = <R>(
  ctx: Interpreter<R>,
-  callback: unknown,
+  callback: Value,
  name: string,
-): ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>) => {
+): ((args: Array<Value>) => Effect.Effect<Value, unknown, R>) => {
  if (!isSupportedCallback(callback)) {
    if (typeofValue(callback) === "function") {
      throw typeError(
@@ -6,10 +6,21 @@ import { type AstNode, formatLocation, PendingThrow, Throw, sourceLocation, type
 import { containsRuntimeReference } from "./references.js"
 import { createErrorValue, type ErrorType, isErrorType } from "./intrinsics.js"
 import { constructor, methods, prototypeFrom, receiver } from "./native.js"
-import { type Callable, define, get, has, hidden, type Native, Arr, ErrorObj, Obj } from "./objects.js"
+import {
+  type Callable,
+  define,
+  get,
+  has,
+  hidden,
+  type Native,
+  Arr,
+  ErrorObj,
+  Obj,
+  coerceToString,
+  type Value,
+} from "./objects.js"
 import type { Interpreter } from "./interpreter.js"
 import { formatValue } from "../stdlib/console.js"
-import { coerceToString } from "../stdlib/value.js"

 export const normalizeError = (error: unknown): Diagnostic => {
  if (error instanceof PendingThrow) {
@@ -86,7 +97,7 @@ export const locate = (error: unknown, node?: AstNode): unknown => {
 }

 /** The program value a handler receives for a failure; one failure always yields the same value. */
-export const materialize = <R>(ctx: Interpreter<R>, thrown: unknown): unknown => {
+export const materialize = <R>(ctx: Interpreter<R>, thrown: unknown): Value => {
  if (thrown instanceof Throw) return thrown.value
  const builtins = ctx.builtins
  if (thrown instanceof PendingThrow) {
@@ -113,7 +124,7 @@ const errorToString = (self: Obj): string => {

 export const createAggregateErrorValue = <R>(
  ctx: Interpreter<R>,
-  errors: Array<unknown>,
+  errors: Array<Value>,
  message: string,
  proto: Obj = ctx.builtins.AggregateError,
 ) => {
@@ -124,13 +135,13 @@ export const createAggregateErrorValue = <R>(

 const constructAggregateErrorValue = <R>(
  ctx: Interpreter<R>,
-  args: Array<unknown>,
+  args: Array<Value>,
  proto: Obj,
 ): Effect.Effect<ErrorObj, unknown, R> =>
  Effect.gen(function* () {
    const cursor = yield* ctx.iterate(args[0])
    if (cursor === undefined) throw typeError("new AggregateError(...) expects a synchronous iterable of errors.")
-    const errors: Array<unknown> = []
+    const errors: Array<Value> = []
    while (true) {
      const step = yield* cursor.next
      if (step.done) {
@@ -144,7 +155,7 @@ const constructAggregateErrorValue = <R>(
 export const errorGlobal = <R>(type: ErrorType, ctx: Interpreter<R>) => {
  const builtins = ctx.builtins
  const prototype = builtins[type]
-  const construct = (args: Array<unknown>, newTarget: Callable) => {
+  const construct = (args: Array<Value>, newTarget: Callable) => {
    const proto = prototypeFrom(newTarget, prototype)
    const created =
      type === "AggregateError"
@@ -168,6 +179,7 @@ export const errorGlobal = <R>(type: ErrorType, ctx: Interpreter<R>) => {
    methods(builtins, prototype, [
      ["toString", 0, (thisValue) => errorToString(receiver(Obj, thisValue, "Error.prototype.toString"))],
    ])
+    methods(builtins, ctor, [["isError", 1, (_, args) => args[0] instanceof ErrorObj]])
  }
  return ctor
 }
@@ -4,6 +4,7 @@ import type { DataValue, Diagnostic, ResolvedExecutionLimits, Result } from "../
 import { toBoundary } from "../data.js"
 import { ToolRuntime } from "../tool-runtime.js"
 import { normalizeError } from "./errors.js"
+import type { Value } from "./objects.js"
 import { createBuiltins } from "./intrinsics.js"
 import { Pending } from "./promises.js"
 import { Interpreter } from "./interpreter.js"
@@ -13,7 +14,7 @@ export const executeProgram = <R>(
  prepared: ToolRuntime.Prepared<R>,
  limits: ResolvedExecutionLimits,
  hooks: ToolRuntime.Hooks<R>,
-  globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, unknown]>,
+  globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, Value]>,
 ): Effect.Effect<Result, never, R> => {
  if (code.trim().length === 0) {
    return Effect.succeed({
@@ -1,6 +1,5 @@
 import { Effect } from "effect"
 import type { Extension } from "../extension.js"
-import { coerceToString } from "../stdlib/value.js"
 import { type ExtensionInvocation, hooked } from "../tool-runtime.js"
 import type { Interpreter } from "./interpreter.js"
 import { createErrorValue, isErrorType } from "./intrinsics.js"
@@ -8,9 +7,7 @@ import { MAX_VALUE_DEPTH } from "./limits.js"
 import { PendingThrow, Throw, typeError } from "./model.js"
 import { fn } from "./native.js"
 import {
-  Callable,
  define,
-  entries,
  get,
  has,
  hidden,
@@ -19,18 +16,17 @@ import {
  Bytes,
  DateObj,
  ErrorObj,
-  GeneratorObj,
-  IteratorObj,
+  HeadersObj,
  MapObj,
  Obj,
-  PromiseObj,
  RegExpObj,
  SetObj,
  URLObj,
  URLSearchParamsObj,
-  HeadersObj,
+  coerceToString,
+  type Value,
 } from "./objects.js"
-import { describeValue } from "./references.js"
+import { describeValue, isOpaque } from "./references.js"

 /**
 * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data and
@@ -40,35 +36,18 @@ import { describeValue } from "./references.js"
 export const extensionGlobals = <R>(
  ctx: Interpreter<R>,
  extensions: ReadonlyArray<Extension>,
-): ReadonlyArray<readonly [string, unknown]> => {
+): ReadonlyArray<readonly [string, Value]> => {
  const builtins = ctx.builtins

-  const toHost = (value: unknown, label: string, depth = 0, seen = new Set<object>()): unknown => {
+  const toHost = (value: Value, label: string, depth = 0, seen = new Set<object>()): unknown => {
    if (depth > MAX_VALUE_DEPTH) throw typeError(`${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`)
-    if (value === null || typeof value !== "object") {
-      if (isPrimitive(value)) return value
-      throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`)
-    }
-    if (value instanceof Bytes) return new Uint8Array(value.bytes)
-    if (value instanceof DateObj) return new Date(value.time)
-    if (value instanceof RegExpObj) return new RegExp(value.regex.source, value.regex.flags)
-    if (value instanceof URLObj) return new URL(value.url.href)
-    if (value instanceof URLSearchParamsObj) return new URLSearchParams(value.params)
-    if (value instanceof HeadersObj) return new Headers(value.headers)
-    const next = (item: unknown) => toHost(item, label, depth + 1, seen)
-    if (value instanceof MapObj) return new Map([...value.map].map(([key, item]) => [next(key), next(item)]))
-    if (value instanceof SetObj) return new Set([...value.set].map(next))
-    if (
-      !(value instanceof Obj) ||
-      value instanceof Callable ||
-      value instanceof GeneratorObj ||
-      value instanceof IteratorObj ||
-      value instanceof PromiseObj
-    ) {
+    if (isPrimitive(value)) return value
+    if (!(value instanceof Obj) || isOpaque(value)) {
      throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`)
    }
    if (seen.has(value)) throw typeError(`${label} contains a circular value.`)
    seen.add(value)
+    const next = (item: Value) => toHost(item, label, depth + 1, seen)
    if (value instanceof ErrorObj) {
      const name = coerceToString(get(value, "name"))
      const message = get(value, "message")
@@ -89,19 +68,12 @@ export const extensionGlobals = <R>(
      seen.delete(value)
      return copied
    }
-    const copied =
-      value instanceof Arr
-        ? value.items.map(next)
-        : Object.fromEntries(
-            entries(value)
-              .filter(([key]) => key !== "__proto__")
-              .map(([key, item]) => [key, next(item)]),
-          )
+    const copied = value.toHost(next)
    seen.delete(value)
    return copied
  }

-  const fromHost = (value: unknown, label: string, depth = 0, seen = new Set<object>()): unknown => {
+  const fromHost = (value: unknown, label: string, depth = 0, seen = new Set<object>()): Value => {
    if (depth > MAX_VALUE_DEPTH) throw typeError(`${label} exceeds the maximum value depth of ${MAX_VALUE_DEPTH}.`)
    if (isPrimitive(value)) return value
    if (typeof value === "function") return wrap(value, label)
@@ -200,7 +172,7 @@ export const extensionGlobals = <R>(
 */
 const uncrossed = new Set(["stack", "constructor", "toString", "__proto__"])
 const left = Symbol("left behind")
-const crossing = (convert: () => unknown): unknown => {
+const crossing = <T>(convert: () => T): T | typeof left => {
  try {
    return convert()
  } catch (reason) {
@@ -219,7 +191,7 @@ const hostErrors = new Map<string, ErrorConstructor>([
 ])

 // The primitives the interpreter operates on; symbols and BigInts are not among them.
-const isPrimitive = (value: unknown): boolean =>
+const isPrimitive = (value: unknown): value is string | number | boolean | null | undefined =>
  value === null ||
  value === undefined ||
  typeof value === "string" ||
@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import { fn, type Method, methods, receiver } from "./native.js"
 import { AsyncIteratorSymbol, type GeneratorRequestKind, IteratorSymbol } from "./model.js"
-import { define, hidden, GeneratorObj } from "./objects.js"
+import { define, hidden, GeneratorObj, type Value } from "./objects.js"
 import type { Interpreter } from "./interpreter.js"

 /** `next`/`return`/`throw` on the generator prototypes; async generators answer with promises. */
@@ -13,9 +13,9 @@ export const generatorGlobals = <R>(ctx: Interpreter<R>): void => {
    const request = (kind: GeneratorRequestKind): Method => [
      kind,
      1,
-      (thisValue: unknown, args: Array<unknown>) => {
+      (thisValue: Value, args: Array<Value>) => {
        const generator = receiver(GeneratorObj, thisValue, `${label}.prototype.${kind}`)
-        const requested = generator.request(kind, args[0]) as Effect.Effect<unknown, unknown, R>
+        const requested = generator.request(kind, args[0]) as Effect.Effect<Value, unknown, R>
        return generator.asynchronous ? ctx.pending.create(requested) : requested
      },
    ]
@@ -1,4 +1,5 @@
 import { Effect } from "effect"
+import type { Value } from "./objects.js"
 import { arrayGlobal } from "../stdlib/array.js"
 import { textDecoderGlobal, textEncoderGlobal, uint8ArrayGlobal } from "../stdlib/bytes.js"
 import { mapGlobal, setGlobal } from "../stdlib/collections.js"
@@ -51,7 +52,7 @@ const symbolGlobal = <R>(ctx: Interpreter<R>) => {
  return symbol
 }

-type Factory = <R>(ctx: Interpreter<R>) => unknown
+type Factory = <R>(ctx: Interpreter<R>) => Value

 // A table rather than a list so the names are known before any runtime exists.
 const table: Record<string, Factory> = {
@@ -69,6 +70,7 @@ const table: Record<string, Factory> = {
  console: (ctx) => consoleGlobal(ctx),
  Promise: (ctx) => promiseGlobal(ctx),
  Symbol: (ctx) => symbolGlobal(ctx),
+  Iterator: (ctx) => iteratorGlobals(ctx),
  Number: (ctx) => numberGlobal(ctx),
  String: (ctx) => stringGlobal(ctx),
  Boolean: (ctx) => booleanGlobal(ctx),
@@ -100,8 +102,7 @@ const table: Record<string, Factory> = {
 export const globalNames: ReadonlySet<string> = new Set(Object.keys(table))

 /** The immutable global bindings of every program, in declaration order. */
-export const globals = <R>(ctx: Interpreter<R>): ReadonlyArray<readonly [string, unknown]> => {
+export const globals = <R>(ctx: Interpreter<R>): ReadonlyArray<readonly [string, Value]> => {
  generatorGlobals(ctx)
-  iteratorGlobals(ctx)
  return Object.entries(table).map(([name, factory]) => [name, factory(ctx)] as const)
 }
@@ -32,6 +32,7 @@ import type {
  Statement,
  Super,
  SwitchStatement,
+  Literal,
  TemplateLiteral,
  ThrowStatement,
  TryStatement,
@@ -62,33 +63,32 @@ import {
 } from "./model.js"
 import { checkStringLength } from "./limits.js"
 import { locate, materialize } from "./errors.js"
-import type { Builtins } from "./intrinsics.js"
+import { type Builtins, primitivePrototype } from "./intrinsics.js"
 import { globals } from "./globals.js"
 import {
  assign,
  Callable,
  define,
  get,
+  hostCursor,
+  IteratorObj,
+  type Cursor,
  has,
  hasPrototype,
  keys,
  Native,
  parseArrayIndex,
  Arr,
-  Bytes,
-  DateObj,
  Fn,
  GeneratorObj,
-  IteratorObj,
-  MapObj,
  Obj,
  PromiseObj,
-  SetObj,
-  URLSearchParamsObj,
-  HeadersObj,
  record,
  remove,
  set,
+  coerceToNumber,
+  coerceToString,
+  type Value,
 } from "./objects.js"
 import { preserveConsumerError } from "./callback.js"
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js"
@@ -96,7 +96,7 @@ import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeof
 import { ScopeStack } from "./scope.js"
 import { constructRegExp } from "../stdlib/regexp.js"
 import { enumerableSource } from "../stdlib/object.js"
-import { coerceToNumber, coerceToString, compoundOperators } from "../stdlib/value.js"
+import { compoundOperators } from "../stdlib/value.js"

 // What a loop does with its body's result: exit with a StatementResult, or undefined to keep iterating.
 // Unlabelled break ends this loop; a label the loop does not carry propagates outward.
@@ -110,24 +110,36 @@ const loopExit = (result: StatementResult, labels: ReadonlySet<string> | undefin
  return undefined
 }

-const calleeDescription = (callee: Expression | Super | undefined): string => {
-  if (callee?.type === "Identifier") return callee.name
-  if (callee?.type === "MemberExpression") {
-    const object = callee.object
-    const property = callee.property
-    const key =
-      !callee.computed && property.type === "Identifier"
-        ? property.name
-        : property.type === "Literal" && typeof property.value === "string"
-          ? property.value
-          : undefined
-    if (object.type === "Identifier" && key !== undefined) return `${object.name}.${key}`
+// Native engines name the callee (`search(...).catch is not a function`), including call chains. Returns
+// undefined when a link cannot be named, so a chain is either named completely or not at all.
+const calleeDescription = (node: Expression | Super | undefined): string | undefined => {
+  if (node?.type === "Identifier") return node.name
+  if (node?.type === "CallExpression") {
+    const target = calleeDescription(node.callee)
+    return target === undefined ? undefined : `${target}(...)`
  }
-  return "The called value"
+  if (node?.type !== "MemberExpression") return undefined
+  const property = node.property
+  const key =
+    !node.computed && property.type === "Identifier"
+      ? property.name
+      : property.type === "Literal" && typeof property.value === "string"
+        ? property.value
+        : undefined
+  if (key === undefined) return undefined
+  const object = calleeDescription(node.object)
+  return object === undefined ? undefined : `${object}.${key}`
 }

 // OrdinaryHasInstance: walk the left operand's chain looking for the constructor's `prototype`.
-const instanceofValue = (lhs: unknown, rhs: unknown, node: AstNode): boolean => {
+// acorn types every literal as possibly a BigInt or RegExp; regex literals become RegExp objects before this is asked.
+const literal = (node: Literal): Value => {
+  if (typeof node.value === "bigint") throw typeError("BigInt literals are not supported.", node)
+  if (node.value instanceof RegExp) throw unsupportedSyntax("RegExpLiteral", node)
+  return node.value
+}
+
+const instanceofValue = (lhs: Value, rhs: Value, node: AstNode): boolean => {
  if (!(rhs instanceof Callable)) {
    throw typeError("The right-hand side of 'instanceof' is not callable.", node)
  }
@@ -224,7 +236,7 @@ const loopDeclaration = (left: VariableDeclaration | Pattern, statement: "for...

 type CustomIterator = {
  iterator: Obj
-  next: unknown
+  next: Value
  asynchronous: boolean
 }

@@ -232,13 +244,13 @@ type CustomIterator = {
 type MemberReference = {
  target: Obj
  key: PropertyKey
-  receiver: unknown
+  receiver: Value
 }

 type GeneratorRequest = {
  kind: GeneratorRequestKind
-  value: unknown
-  response: Deferred.Deferred<unknown, unknown>
+  value: Value
+  response: Deferred.Deferred<Value, unknown>
 }

 type GeneratorState = {
@@ -264,7 +276,7 @@ export class Interpreter<R> {
    readonly pending: Pending<R>
    readonly builtins: Builtins
    readonly logs?: Array<string>
-    readonly globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, unknown]>
+    readonly globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, Value]>
  }) {
    this.tools = options.tools
    this.pending = options.pending
@@ -278,27 +290,31 @@ export class Interpreter<R> {
    }
  }

-  run(program: Program): Effect.Effect<unknown, unknown, R> {
+  run(program: Program): Effect.Effect<Value, unknown, R> {
    return this.root.run(program)
  }

-  call(callable: unknown, thisValue: unknown, args: Array<unknown>): Effect.Effect<unknown, unknown, R> {
+  call(callable: Value, thisValue: Value, args: Array<Value>): Effect.Effect<Value, unknown, R> {
    return this.root.call(callable, thisValue, args)
  }

-  await(promise: PromiseObj): Effect.Effect<unknown, unknown, never> {
+  await(promise: PromiseObj): Effect.Effect<Value, unknown, never> {
    return this.root.await(promise)
  }

-  iterate(value: unknown) {
+  iterate(value: Value) {
    return this.root.iterate(value)
  }

+  iterateDirect(value: Value) {
+    return this.root.iterateDirect(value)
+  }
+
  /** Runs one host tool: arguments cross as JSON and the result comes back as program values. */
  tool(
    run: (args: Array<Json | undefined>) => Effect.Effect<Json | undefined, unknown, R>,
-    args: Array<unknown>,
-  ): Effect.Effect<unknown, unknown, R> {
+    args: Array<Value>,
+  ): Effect.Effect<Value, unknown, R> {
    const ctx = this
    return Effect.gen(function* () {
      const json = yield* Effect.forEach(args, (arg) => toBoundary(ctx, arg))
@@ -321,7 +337,7 @@ class Frame<R> {
    private depth = 0,
  ) {}

-  run(program: Program): Effect.Effect<unknown, unknown, R> {
+  run(program: Program): Effect.Effect<Value, unknown, R> {
    const self = this
    // Keep top-level declarations separate so they can shadow builtins.
    this.scopes.push()
@@ -329,7 +345,7 @@ class Frame<R> {
      self.predeclareLexical(program.body)
      self.hoistFunctions(program.body)
      self.hoistVars(program.body)
-      let value: unknown = undefined
+      let value: Value = undefined
      for (const [index, statement] of program.body.entries()) {
        if (index === program.body.length - 1 && statement.type === "ExpressionStatement") {
          value = yield* self.evaluateExpression(statement.expression)
@@ -354,15 +370,12 @@ class Frame<R> {
  }

  // Fork at the call site so admission and hooks occur when the call is made.
-  private createToolCallPromise(
-    path: ReadonlyArray<string>,
-    args: Array<unknown>,
-  ): Effect.Effect<PromiseObj, never, R> {
+  private createToolCallPromise(path: ReadonlyArray<string>, args: Array<Value>): Effect.Effect<PromiseObj, never, R> {
    return this.ctx.pending.create(this.ctx.tool((json) => this.ctx.tools.execute(path, json), args))
  }

  // Fiber exits make settlement idempotent; yielding prevents inline continuation.
-  await(promise: PromiseObj): Effect.Effect<unknown, unknown, never> {
+  await(promise: PromiseObj): Effect.Effect<Value, unknown, never> {
    const pending = this.ctx.pending
    return Effect.suspend(() => {
      pending.markObserved(promise)
@@ -453,7 +466,7 @@ class Frame<R> {
  }

  // NamedEvaluation: an anonymous function definition takes the name of what it is assigned to.
-  private evaluateNamed(node: Expression, name: string): Effect.Effect<unknown, unknown, R> {
+  private evaluateNamed(node: Expression, name: string): Effect.Effect<Value, unknown, R> {
    if (node.type === "ArrowFunctionExpression" || (node.type === "FunctionExpression" && !node.id)) {
      return Effect.sync(() => this.createFunction(node, name))
    }
@@ -651,11 +664,11 @@ class Frame<R> {
      if (declared?.lexical) self.predeclarePattern(declared.pattern, declared.mutable, left)
      const right = yield* self.evaluateExpression(node.right)

-      const cursor = self.hostCursor(right)
+      const cursor = self.builtinCursor(right)
      const iterator = cursor === undefined ? yield* self.customIterator(right, node, awaiting) : undefined
      if (iterator === undefined && cursor === undefined) {
        throw invalidData(
-          `${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, URLSearchParams, or Headers, or custom iterator value.`,
+          `${awaiting ? "for await...of" : "for...of"} requires an iterable value, received ${describeValue(right)}.`,
          node,
        )
      }
@@ -671,7 +684,7 @@ class Frame<R> {
      }
      const assignment = left.type === "VariableDeclaration" ? undefined : left

-      const evaluateBody = (value: unknown) =>
+      const evaluateBody = (value: Value) =>
        Effect.gen(function* () {
          if (declared?.lexical) {
            self.scopes.push()
@@ -700,10 +713,8 @@ class Frame<R> {
        const bodyExit = yield* Effect.exit(evaluateBody(step.value))
        if (!Exit.isSuccess(bodyExit)) {
          // Process interruption must remain prompt; user cleanup cannot extend a timeout.
-          if (!Cause.hasInterruptsOnly(bodyExit.cause)) {
-            yield* Effect.exit(close())
-          }
-          return yield* Effect.failCause(bodyExit.cause)
+          if (Cause.hasInterruptsOnly(bodyExit.cause)) return yield* Effect.failCause(bodyExit.cause)
+          return yield* preserveConsumerError(close(), Effect.failCause(bodyExit.cause))
        }
        const exit = loopExit(bodyExit.value, labels)
        if (exit !== undefined) {
@@ -720,7 +731,7 @@ class Frame<R> {
    )
  }

-  private awaitValue(value: unknown): Effect.Effect<unknown, unknown, R> {
+  private awaitValue(value: Value): Effect.Effect<Value, unknown, R> {
    return Effect.flatMap(resolvePromise(this.ctx, value), (promise) =>
      Effect.ensuring(
        this.await(promise),
@@ -731,10 +742,10 @@ class Frame<R> {

  private awaitAsyncFromSyncValue(
    iterator: CustomIterator,
-    value: unknown,
+    value: Value,
    node: AstNode | undefined,
    closeOnRejection: boolean,
-  ): Effect.Effect<unknown, unknown, R> {
+  ): Effect.Effect<Value, unknown, R> {
    const self = this
    return Effect.gen(function* () {
      const settled = yield* Effect.exit(self.awaitValue(value))
@@ -746,54 +757,50 @@ class Frame<R> {
    })
  }

-  iterate(value: unknown, node?: AstNode) {
-    const cursor = this.hostCursor(value)
+  iterate(value: Value, node?: AstNode): Effect.Effect<Cursor<R> | undefined, unknown, R> {
+    const cursor = this.builtinCursor(value)
    if (cursor !== undefined) return Effect.succeed(cursor)
-    const self = this
    return Effect.map(this.customIterator(value, node, false), (iterator) =>
-      iterator === undefined
-        ? undefined
-        : {
-            next: self.nextIteratorResult(iterator, node, false),
-            close: Effect.suspend(() => self.closeIterator(iterator, node, false)),
-          },
+      iterator === undefined ? undefined : this.customCursor(iterator, node),
    )
  }

-  private hostCursor(value: unknown) {
-    const iterator =
-      value instanceof Arr
-        ? value.items[Symbol.iterator]()
-        : typeof value === "string"
-          ? value[Symbol.iterator]()
-          : value instanceof MapObj
-            ? value.map.entries()
-            : value instanceof SetObj
-              ? value.set.values()
-              : value instanceof URLSearchParamsObj
-                ? value.params.entries()
-                : value instanceof HeadersObj
-                  ? value.headers.entries()
-                  : value instanceof Bytes
-                    ? value.bytes.values()
-                    : value instanceof IteratorObj
-                      ? value.iterator
-                      : undefined
-    if (iterator === undefined) return undefined
-    const proto = this.ctx.builtins.Array
+  /** GetIteratorDirect: drive an iterator by its own `next`, without asking for `[Symbol.iterator]`. */
+  iterateDirect(value: Value, node?: AstNode): Cursor<R> {
+    if (value instanceof IteratorObj) return value.cursor as Cursor<R>
+    if (!(value instanceof Obj)) {
+      throw typeError(`An iterator must be an object, received ${describeValue(value)}.`, node)
+    }
+    return this.customCursor(
+      {
+        iterator: value,
+        next: this.requireIteratorMethod(get(value, "next"), "Iterator next", node),
+        asynchronous: false,
+      },
+      node,
+    )
+  }
+
+  private customCursor(iterator: CustomIterator, node: AstNode | undefined): Cursor<R> {
    return {
-      next: Effect.sync(() => {
-        const step = iterator.next()
-        return {
-          done: Boolean(step.done),
-          value: Array.isArray(step.value) ? new Arr(proto, step.value) : step.value,
-        }
-      }),
-      close: Effect.void,
+      next: this.nextIteratorResult(iterator, node, false),
+      close: Effect.suspend(() => this.closeIterator(iterator, node, false)),
    }
  }

-  private customIterator(value: unknown, node: AstNode | undefined, allowAsync = true) {
+  private builtinCursor(value: Value): Cursor<R> | undefined {
+    // Natives build their cursors without knowing R, like `lift` in native.ts.
+    if (value instanceof IteratorObj) return value.cursor as Cursor<R>
+    const iterator =
+      typeof value === "string"
+        ? value[Symbol.iterator]()
+        : value instanceof Obj
+          ? value.iterator(this.ctx.builtins)
+          : undefined
+    return iterator === undefined ? undefined : hostCursor(iterator)
+  }
+
+  private customIterator(value: Value, node: AstNode | undefined, allowAsync = true) {
    if (!(value instanceof Obj)) return Effect.undefined
    const asyncMethod = allowAsync ? get(value, AsyncIteratorSymbol) : undefined
    const method = asyncMethod ?? get(value, IteratorSymbol)
@@ -883,18 +890,18 @@ class Frame<R> {
    })
  }

-  private requireIteratorObject(value: unknown, context: string, node?: AstNode): Obj {
+  private requireIteratorObject(value: Value, context: string, node?: AstNode): Obj {
    if (value instanceof Obj) return value
    throw typeError(`${context} must be an object.`, node)
  }

-  private requireIteratorMethod(value: unknown, context: string, node?: AstNode): unknown {
+  private requireIteratorMethod(value: Value, context: string, node?: AstNode): Value {
    if (typeofValue(value) === "function") return value
    throw typeError(`${context} must be a function.`, node)
  }

  // for...in over null/undefined iterates nothing, like JS.
-  private enumerableKeys(value: unknown, node: AstNode): Array<string> {
+  private enumerableKeys(value: Value, node: AstNode): Array<string> {
    if (value instanceof ToolReference) return [...this.ctx.tools.keys(value.path)]
    if (value === null || value === undefined) return []
    return keys(enumerableSource(this.ctx, "for...in", value, node))
@@ -1058,7 +1065,7 @@ class Frame<R> {

  private declarePattern(
    pattern: Pattern,
-    value: unknown,
+    value: Value,
    mutable: boolean,
    node: AstNode,
    initialize = false,
@@ -1118,7 +1125,7 @@ class Frame<R> {
    })
  }

-  private assignPattern(pattern: Pattern, value: unknown, node: AstNode): Effect.Effect<void, unknown, R> {
+  private assignPattern(pattern: Pattern, value: Value, node: AstNode): Effect.Effect<void, unknown, R> {
    const self = this
    return Effect.gen(function* () {
      if (pattern.type === "Identifier") {
@@ -1170,7 +1177,7 @@ class Frame<R> {
    })
  }

-  private evaluateDefault(pattern: AssignmentPattern): Effect.Effect<unknown, unknown, R> {
+  private evaluateDefault(pattern: AssignmentPattern): Effect.Effect<Value, unknown, R> {
    return pattern.left.type === "Identifier"
      ? this.evaluateNamed(pattern.right, pattern.left.name)
      : this.evaluateExpression(pattern.right)
@@ -1178,8 +1185,8 @@ class Frame<R> {

  private destructureArrayPattern(
    pattern: ArrayPattern,
-    value: unknown,
-    consume: (target: Pattern, value: unknown, context: AstNode) => Effect.Effect<void, unknown, R>,
+    value: Value,
+    consume: (target: Pattern, value: Value, context: AstNode) => Effect.Effect<void, unknown, R>,
  ): Effect.Effect<void, unknown, R> {
    const self = this
    return Effect.gen(function* () {
@@ -1203,7 +1210,7 @@ class Frame<R> {
        done = step.done
        if (element === null) continue
        if (element.type === "RestElement") {
-          const rest: Array<unknown> = []
+          const rest: Array<Value> = []
          if (!step.done) rest.push(step.value)
          while (!done) {
            const next = yield* cursor.next
@@ -1214,7 +1221,7 @@ class Frame<R> {
          return
        }
        const consumed = consume(element, step.done ? undefined : step.value, pattern)
-        yield* step.done ? consumed : preserveConsumerError(cursor, consumed)
+        yield* step.done ? consumed : preserveConsumerError(cursor.close, consumed)
      }
      if (!done) yield* cursor.close
    })
@@ -1233,13 +1240,12 @@ class Frame<R> {
    throw unsupportedSyntax(keyNode.type, keyNode)
  }

-  private evaluateExpression(node: Expression): Effect.Effect<unknown, unknown, R> {
+  private evaluateExpression(node: Expression): Effect.Effect<Value, unknown, R> {
    switch (node.type) {
      case "Literal": {
        const regex = node.regex
        if (regex) return Effect.sync(() => constructRegExp(this.ctx.builtins, [regex.pattern, regex.flags]))
-        if (typeof node.value === "bigint") throw typeError("BigInt literals are not supported.", node)
-        return Effect.succeed(node.value)
+        return Effect.succeed(literal(node))
      }
      case "Identifier":
        return Effect.sync(() => this.scopes.get(node.name, node))
@@ -1254,7 +1260,7 @@ class Frame<R> {
      case "SequenceExpression": {
        const self = this
        return Effect.gen(function* () {
-          let result: unknown
+          let result: Value
          for (const expression of node.expressions) {
            result = yield* self.evaluateExpression(expression)
          }
@@ -1295,7 +1301,7 @@ class Frame<R> {
    }
  }

-  private evaluateNewExpression(node: NewExpression): Effect.Effect<unknown, unknown, R> {
+  private evaluateNewExpression(node: NewExpression): Effect.Effect<Value, unknown, R> {
    const self = this
    return Effect.gen(function* () {
      const callee = yield* self.evaluateExpression(node.callee)
@@ -1305,7 +1311,7 @@ class Frame<R> {
        // `new` itself is supported, so a non-constructible callee is a TypeError like JS rather than
        // unsupported syntax. Built-ins like Number are real constructors in JS, so do not claim
        // otherwise; say `new` is unsupported for them and point at the plain call.
-        const name = calleeDescription(node.callee)
+        const name = calleeDescription(node.callee) ?? "The called value"
        const message =
          callee instanceof Fn
            ? `${name} cannot be constructed: user-defined constructors and classes are not supported. Call it as a function that returns a plain object instead.`
@@ -1319,7 +1325,7 @@ class Frame<R> {
    })
  }

-  private evaluateBinaryExpression(node: BinaryExpression): Effect.Effect<unknown, unknown, R> {
+  private evaluateBinaryExpression(node: BinaryExpression): Effect.Effect<Value, unknown, R> {
    const operator = node.operator
    const left = node.left
    if (left.type === "PrivateIdentifier") throw unsupportedSyntax(left.type, left)
@@ -1332,7 +1338,7 @@ class Frame<R> {
    })
  }

-  private applyBinaryOperator(operator: string, lhs: unknown, rhs: unknown, node: AstNode): unknown {
+  private applyBinaryOperator(operator: string, lhs: Value, rhs: Value, node: AstNode): Value {
    if (operator === "===") return lhs === rhs
    if (operator === "!==") return lhs !== rhs
    if (operator === "in" && rhs instanceof Obj && !containsOpaqueReference(lhs)) {
@@ -1341,14 +1347,9 @@ class Frame<R> {
    if (containsOpaqueReference(lhs) || containsOpaqueReference(rhs)) {
      throw invalidData("Binary operators require data values.", node)
    }
-    // Null-prototype data needs explicit primitive coercion; identity and `in` retain raw objects.
-    // Dates use their default string hint for addition and loose equality, and epoch time elsewhere.
-    const coerceOperand = (operand: unknown): unknown => {
-      if (operand instanceof DateObj) {
-        return operator === "+" || operator === "==" || operator === "!=" ? coerceToString(operand) : operand.time
-      }
-      return operand !== null && typeof operand === "object" ? coerceToString(operand) : operand
-    }
+    // Addition and loose equality use the default hint; every other operator asks for a number.
+    const hint = operator === "+" || operator === "==" || operator === "!=" ? "default" : "number"
+    const coerceOperand = (operand: Value) => (operand instanceof Obj ? operand.toPrimitive(hint) : operand)
    const bothObjects = lhs !== null && typeof lhs === "object" && rhs !== null && typeof rhs === "object"
    const l = coerceOperand(lhs)
    const r = coerceOperand(rhs)
@@ -1402,7 +1403,7 @@ class Frame<R> {
    }
  }

-  private evaluateLogicalExpression(node: LogicalExpression): Effect.Effect<unknown, unknown, R> {
+  private evaluateLogicalExpression(node: LogicalExpression): Effect.Effect<Value, unknown, R> {
    const operator = node.operator
    return Effect.flatMap(this.evaluateExpression(node.left), (left) => {
      if (operator === "&&") return left ? this.evaluateExpression(node.right) : Effect.succeed(left)
@@ -1413,7 +1414,7 @@ class Frame<R> {
    })
  }

-  private evaluateUnaryExpression(node: UnaryExpression): Effect.Effect<unknown, unknown, R> {
+  private evaluateUnaryExpression(node: UnaryExpression): Effect.Effect<Value, unknown, R> {
    const operator = node.operator
    const argument = node.argument
    if (operator === "delete") return this.evaluateDeleteExpression(argument)
@@ -1428,13 +1429,8 @@ class Frame<R> {
      if (containsOpaqueReference(value)) {
        throw invalidData("Unary operators require data values.", node)
      }
-      const operand =
-        value instanceof DateObj
-          ? value.time
-          : value !== null && typeof value === "object"
-            ? coerceToString(value)
-            : value
-      let result: unknown
+      const operand = value instanceof Obj ? value.toPrimitive("number") : value
+      let result: Value
      switch (operator) {
        case "+":
          result = +(operand as number)
@@ -1452,7 +1448,7 @@ class Frame<R> {
    })
  }

-  private evaluateAssignmentExpression(node: AssignmentExpression): Effect.Effect<unknown, unknown, R> {
+  private evaluateAssignmentExpression(node: AssignmentExpression): Effect.Effect<Value, unknown, R> {
    const left = node.left
    const operator = node.operator
    const self = this
@@ -1492,9 +1488,9 @@ class Frame<R> {
    node: AssignmentExpression,
    left: Pattern,
    operator: string,
-  ): Effect.Effect<unknown, unknown, R> {
+  ): Effect.Effect<Value, unknown, R> {
    const self = this
-    const shouldAssign = (current: unknown): boolean =>
+    const shouldAssign = (current: Value): boolean =>
      operator === "??=" ? current === null || current === undefined : operator === "||=" ? !current : Boolean(current)
    if (left.type === "Identifier") {
      const name = left.name
@@ -1519,7 +1515,7 @@ class Frame<R> {
    throw typeError("Assignment target must be an Identifier or MemberExpression.", left)
  }

-  private evaluateUpdateExpression(node: UpdateExpression): Effect.Effect<unknown, unknown, R> {
+  private evaluateUpdateExpression(node: UpdateExpression): Effect.Effect<Value, unknown, R> {
    const operator = node.operator
    const argument = node.argument
    const prefix = node.prefix
@@ -1532,7 +1528,7 @@ class Frame<R> {

    // CodeMode numeric coercion, not host Number(): null-prototype data objects would make
    // the host throw during ToPrimitive, and opaque runtime references must reject clearly.
-    const operand = (current: unknown): number => {
+    const operand = (current: Value): number => {
      if (containsOpaqueReference(current)) {
        throw invalidData(`'${operator}' requires a data value.`, argument)
      }
@@ -1561,7 +1557,7 @@ class Frame<R> {
  }

  // EvaluateCall: a member callee supplies its base object as `this`; anything else calls with undefined.
-  private evaluateCallExpression(node: CallExpression): Effect.Effect<unknown, unknown, R> {
+  private evaluateCallExpression(node: CallExpression): Effect.Effect<Value, unknown, R> {
    const callee = node.callee

    const self = this
@@ -1579,7 +1575,7 @@ class Frame<R> {
    })
  }

-  private readMethod(node: MemberExpression): Effect.Effect<{ callable: unknown; thisValue: unknown }, unknown, R> {
+  private readMethod(node: MemberExpression): Effect.Effect<{ callable: Value; thisValue: Value }, unknown, R> {
    return Effect.map(this.getMemberReference(node), (reference) => {
      if (reference === OptionalShortCircuit) return { callable: OptionalShortCircuit, thisValue: undefined }
      if (reference instanceof ToolReference) return { callable: reference, thisValue: undefined }
@@ -1590,12 +1586,12 @@ class Frame<R> {

  // The single dispatch for every invocation: call expressions and callbacks share it.
  call(
-    callable: unknown,
-    thisValue: unknown,
-    args: Array<unknown>,
+    callable: Value,
+    thisValue: Value,
+    args: Array<Value>,
    node?: AstNode,
    callee?: Expression,
-  ): Effect.Effect<unknown, unknown, R> {
+  ): Effect.Effect<Value, unknown, R> {
    const self = this
    return Effect.gen(function* () {
      if (callable instanceof ToolReference) {
@@ -1608,12 +1604,12 @@ class Frame<R> {
      if (callable instanceof Native) {
        return yield* self.native(() => (callable as Native<R>).call(thisValue, args), node)
      }
-      throw typeError(`${calleeDescription(callee)} is not a function.`, callee ?? node)
+      throw typeError(`${calleeDescription(callee) ?? "The called value"} is not a function.`, callee ?? node)
    })
  }

  // Built-ins throw without a location, synchronously or inside their Effect; the call site supplies it.
-  private native(body: () => Effect.Effect<unknown, unknown, R>, node?: AstNode): Effect.Effect<unknown, unknown, R> {
+  private native(body: () => Effect.Effect<Value, unknown, R>, node?: AstNode): Effect.Effect<Value, unknown, R> {
    return Effect.provideService(
      Effect.catchDefect(Effect.suspend(body), (defect) => Effect.die(locate(defect, node))),
      CallSite,
@@ -1623,10 +1619,10 @@ class Frame<R> {

  private evaluateCallArguments(
    argNodes: ReadonlyArray<Expression | SpreadElement>,
-  ): Effect.Effect<Array<unknown>, unknown, R> {
+  ): Effect.Effect<Array<Value>, unknown, R> {
    const self = this
    return Effect.gen(function* () {
-      const args: Array<unknown> = []
+      const args: Array<Value> = []
      for (const argNode of argNodes) {
        if (argNode.type === "SpreadElement") {
          const spread = yield* self.evaluateExpression(argNode.argument)
@@ -1646,7 +1642,7 @@ class Frame<R> {
  }

  // A callback invoked by a built-in runs below the call that invoked the built-in, so the deeper of the two counts.
-  invokeFunction(fn: Fn, args: Array<unknown>, node?: AstNode): Effect.Effect<unknown, unknown, R> {
+  invokeFunction(fn: Fn, args: Array<Value>, node?: AstNode): Effect.Effect<Value, unknown, R> {
    const self = this
    return Effect.flatMap(CallSite, (site) => {
      const depth = Math.max(self.depth, site.depth) + 1
@@ -1693,16 +1689,16 @@ class Frame<R> {

  private createGenerator(
    invocation: Frame<R>,
-    run: Effect.Effect<unknown, unknown, R>,
+    run: Effect.Effect<Value, unknown, R>,
    asynchronous: boolean,
  ): GeneratorObj {
    const state: GeneratorState = { started: false, completed: false, draining: false, pending: [], pendingIndex: 0 }
    invocation.generatorState = state
    invocation.generatorAsync = asynchronous
    const builtins = this.ctx.builtins
-    const result = (value: unknown, done: boolean) => record(builtins.Object, { value, done })
-    const request = (kind: GeneratorRequestKind, value: unknown) => {
-      const request = { kind, value, response: Deferred.makeUnsafe<unknown, unknown>() }
+    const result = (value: Value, done: boolean) => record(builtins.Object, { value, done })
+    const request = (kind: GeneratorRequestKind, value: Value) => {
+      const request = { kind, value, response: Deferred.makeUnsafe<Value, unknown>() }
      if (!asynchronous && state.active) return Effect.die(typeError("Generator is already running."))
      if (asynchronous && (state.completed || (!state.started && kind !== "next"))) {
        state.started = true
@@ -1773,7 +1769,7 @@ class Frame<R> {

  private completeGeneratorRequests(state: GeneratorState, asynchronous: boolean): Effect.Effect<void, never, R> {
    const self = this
-    const result = (value: unknown, done: boolean) => record(self.ctx.builtins.Object, { value, done })
+    const result = (value: Value, done: boolean) => record(self.ctx.builtins.Object, { value, done })
    return Effect.gen(function* () {
      while (true) {
        const pending = self.dequeueGeneratorRequest(state)
@@ -1819,7 +1815,7 @@ class Frame<R> {
    return request
  }

-  private evaluateYieldExpression(node: YieldExpression): Effect.Effect<unknown, unknown, R> {
+  private evaluateYieldExpression(node: YieldExpression): Effect.Effect<Value, unknown, R> {
    const argument = node.argument
    const self = this
    return Effect.gen(function* () {
@@ -1834,7 +1830,7 @@ class Frame<R> {
    })
  }

-  private suspendGenerator(value: unknown, node: AstNode): Effect.Effect<unknown, unknown, R> {
+  private suspendGenerator(value: Value, node: AstNode): Effect.Effect<Value, unknown, R> {
    const state = this.generatorState
    if (!state?.active) throw typeError("Generator has no active request.", node)
    Deferred.doneUnsafe(state.active.response, Exit.succeed(record(this.ctx.builtins.Object, { value, done: false })))
@@ -1849,20 +1845,11 @@ class Frame<R> {
    })
  }

-  private delegateYield(value: unknown, node: AstNode): Effect.Effect<unknown, unknown, R> {
+  private delegateYield(value: Value, node: AstNode): Effect.Effect<Value, unknown, R> {
    const self = this
    return Effect.gen(function* () {
-      if (
-        value instanceof Arr ||
-        typeof value === "string" ||
-        value instanceof MapObj ||
-        value instanceof SetObj ||
-        value instanceof URLSearchParamsObj ||
-        value instanceof HeadersObj ||
-        value instanceof Bytes
-      ) {
-        const cursor = yield* self.iterate(value, node)
-        if (!cursor) throw typeError("Built-in iterator is unavailable.", node)
+      const cursor = self.builtinCursor(value)
+      if (cursor !== undefined) {
        while (true) {
          const step = yield* cursor.next
          if (step.done) return undefined
@@ -1886,7 +1873,7 @@ class Frame<R> {
      const iterator = yield* self.customIterator(value, node, self.generatorAsync)
      if (!iterator) throw typeError("yield* requires a compatible iterable value.", node)
      let kind: GeneratorRequestKind = "next"
-      let input: unknown = undefined
+      let input: Value = undefined
      while (true) {
        const method = kind === "next" ? iterator.next : get(iterator.iterator, kind)
        if (method === undefined || method === null) {
@@ -1906,7 +1893,7 @@ class Frame<R> {
          node,
        )
        const done = Boolean(get(result, "done"))
-        const resultValue: unknown =
+        const resultValue: Value =
          self.generatorAsync && !iterator.asynchronous
            ? yield* self.awaitAsyncFromSyncValue(iterator, get(result, "value"), node, kind !== "return" && !done)
            : get(result, "value")
@@ -1915,7 +1902,7 @@ class Frame<R> {
          return resultValue
        }

-        const resumed: Exit.Exit<unknown, unknown> = yield* Effect.exit(self.suspendGenerator(resultValue, node))
+        const resumed: Exit.Exit<Value, unknown> = yield* Effect.exit(self.suspendGenerator(resultValue, node))
        if (Exit.isSuccess(resumed)) {
          kind = "next"
          input = resumed.value
@@ -1956,7 +1943,7 @@ class Frame<R> {
        } else if (keyNode.type === "Identifier") {
          key = keyNode.name
        } else if (keyNode.type === "Literal") {
-          key = self.toPropertyKey(keyNode.value, keyNode)
+          key = self.toPropertyKey(literal(keyNode), keyNode)
        } else {
          throw typeError("Unsupported object property key shape.", keyNode)
        }
@@ -1975,7 +1962,7 @@ class Frame<R> {
  }

  private evaluateArrayExpression(node: ArrayExpression): Effect.Effect<Arr, unknown, R> {
-    const values: Array<unknown> = []
+    const values: Array<Value> = []

    const self = this
    return Effect.gen(function* () {
@@ -2030,13 +2017,13 @@ class Frame<R> {
    })
  }

-  private evaluateConditionalExpression(node: ConditionalExpression): Effect.Effect<unknown, unknown, R> {
+  private evaluateConditionalExpression(node: ConditionalExpression): Effect.Effect<Value, unknown, R> {
    return Effect.flatMap(this.evaluateExpression(node.test), (test) =>
      this.evaluateExpression(test ? node.consequent : node.alternate),
    )
  }

-  private applyCompoundAssignment(operator: string, current: unknown, incoming: unknown, node: AstNode): unknown {
+  private applyCompoundAssignment(operator: string, current: Value, incoming: Value, node: AstNode): Value {
    if (!compoundOperators.has(operator)) {
      throw typeError(`Unsupported assignment operator '${operator}'.`, node)
    }
@@ -2045,7 +2032,7 @@ class Frame<R> {

  private getMemberReference(
    node: MemberExpression,
-  ): Effect.Effect<MemberReference | ToolReference | { value: unknown } | typeof OptionalShortCircuit, unknown, R> {
+  ): Effect.Effect<MemberReference | ToolReference | { value: Value } | typeof OptionalShortCircuit, unknown, R> {
    const objectNode = node.object
    const propertyNode = node.property
    if (objectNode.type === "Super") throw unsupportedSyntax(objectNode.type, objectNode)
@@ -2071,16 +2058,14 @@ class Frame<R> {

      if (objectValue instanceof Obj) return { target: objectValue, key, receiver: objectValue }

-      // Primitives read through their wrapper prototype without being boxed; strings own length and indexes.
-      const builtins = self.ctx.builtins
+      // Strings own length and indexes; every other primitive property reads through the wrapper prototype.
      if (typeof objectValue === "string") {
        if (key === "length") return { value: objectValue.length }
        const index = typeof key === "symbol" ? undefined : parseArrayIndex(key)
        if (index !== undefined) return { value: objectValue[index] }
-        return { target: builtins.String, key, receiver: objectValue }
      }
-      if (typeof objectValue === "number") return { target: builtins.Number, key, receiver: objectValue }
-      if (typeof objectValue === "boolean") return { target: builtins.Boolean, key, receiver: objectValue }
+      const proto = primitivePrototype(self.ctx.builtins, objectValue)
+      if (proto !== undefined) return { target: proto, key, receiver: objectValue }

      if (objectValue === null || objectValue === undefined) {
        throw typeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode)
@@ -2089,7 +2074,7 @@ class Frame<R> {
    })
  }

-  private readReference(reference: MemberReference, node: MemberExpression): unknown {
+  private readReference(reference: MemberReference, node: MemberExpression): Value {
    // Reject unknown promise properties so a missing await cannot hide.
    if (reference.target instanceof PromiseObj && !has(reference.target, reference.key)) {
      throw invalidData(
@@ -2101,7 +2086,7 @@ class Frame<R> {
  }

  // Accessors throw without a location; the member or pattern that read them supplies it.
-  private readProperty(target: Obj, key: PropertyKey, node: AstNode, receiver: unknown = target): unknown {
+  private readProperty(target: Obj, key: PropertyKey, node: AstNode, receiver: Value = target): Value {
    try {
      return get(target, key, receiver)
    } catch (error) {
@@ -2109,7 +2094,7 @@ class Frame<R> {
    }
  }

-  private readMember(node: MemberExpression): Effect.Effect<unknown, unknown, R> {
+  private readMember(node: MemberExpression): Effect.Effect<Value, unknown, R> {
    return Effect.map(this.getMemberReference(node), (reference) => {
      if (reference === OptionalShortCircuit) return OptionalShortCircuit
      if (reference instanceof ToolReference) return reference
@@ -2118,7 +2103,7 @@ class Frame<R> {
    })
  }

-  private writeMember(node: MemberExpression, value: unknown): Effect.Effect<unknown, unknown, R> {
+  private writeMember(node: MemberExpression, value: Value): Effect.Effect<Value, unknown, R> {
    return this.modifyMember(node, () => Effect.succeed({ write: true, next: value, result: value }))
  }

@@ -2140,8 +2125,8 @@ class Frame<R> {
  // Resolve side-effecting object and key expressions exactly once.
  private modifyMember(
    node: MemberExpression,
-    compute: (current: unknown) => Effect.Effect<{ write: boolean; next: unknown; result: unknown }, unknown, R>,
-  ): Effect.Effect<unknown, unknown, R> {
+    compute: (current: Value) => Effect.Effect<{ write: boolean; next: Value; result: Value }, unknown, R>,
+  ): Effect.Effect<Value, unknown, R> {
    const self = this
    return Effect.gen(function* () {
      const reference = yield* self.getMemberReference(node)
@@ -2161,7 +2146,7 @@ class Frame<R> {
    })
  }

-  private assignToReference(target: Obj, key: PropertyKey, next: unknown, node: AstNode): void {
+  private assignToReference(target: Obj, key: PropertyKey, next: Value, node: AstNode): void {
    const written = (() => {
      try {
        rejectCircularInsertion(
@@ -2179,7 +2164,7 @@ class Frame<R> {
    throw typeError(`Cannot assign to read only property '${String(key)}'.`, node)
  }

-  private toPropertyKey(value: unknown, node: AstNode): PropertyKey {
+  private toPropertyKey(value: Value, node: AstNode): PropertyKey {
    if (typeof value === "string" || typeof value === "number") {
      return value
    }
@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define, hidden, Native, Arr, ErrorObj, Obj } from "./objects.js"
+import { define, hidden, Native, Arr, ErrorObj, Obj, type Value } from "./objects.js"

 export const errorTypes = [
  "Error",
@@ -35,6 +35,7 @@ const builtins = [
  "TextDecoder",
  "Promise",
  "Iterator",
+  "IteratorHelper",
  "AsyncIterator",
  "Generator",
  "AsyncGenerator",
@@ -52,6 +53,14 @@ export const createErrorValue = (prototype: Obj, message: string | undefined): E
  return value
 }

+/** The prototype a primitive reads its methods from without being boxed; none for null, undefined, and symbols. */
+export const primitivePrototype = (builtins: Builtins, value: Value): Obj | undefined => {
+  if (typeof value === "string") return builtins.String
+  if (typeof value === "number") return builtins.Number
+  if (typeof value === "boolean") return builtins.Boolean
+  return undefined
+}
+
 export const createBuiltins = (): Builtins => {
  const object = new Obj(null)
  // Function.prototype is itself callable and returns undefined.
@@ -87,6 +96,7 @@ export const createBuiltins = (): Builtins => {
    TextDecoder: plain(),
    Promise: plain(),
    Iterator: iterator,
+    IteratorHelper: new Obj(iterator),
    AsyncIterator: asyncIterator,
    Generator: new Obj(iterator),
    AsyncGenerator: new Obj(asyncIterator),
@@ -2,7 +2,7 @@ import type { Node } from "acorn"
 import { Context } from "effect"
 import type { ErrorType } from "./intrinsics.js"
 import type { DiagnosticKind } from "../codemode.js"
-import type { ErrorObj } from "./objects.js"
+import type { ErrorObj, Value } from "./objects.js"

 /** Any parsed node; the interpreter narrows on `type` and reads `loc` for diagnostics. */
 export type AstNode = Node
@@ -14,13 +14,13 @@ export const CallSite = Context.Reference<{ readonly node?: AstNode; readonly de

 export type Binding = {
  mutable: boolean
-  value: unknown
+  value: Value
  initialized?: boolean
 }

 export type StatementResult =
  | { kind: "none" }
-  | { kind: "return"; value: unknown }
+  | { kind: "return"; value: Value }
  | { kind: "break"; label?: string }
  | { kind: "continue"; label?: string }

@@ -31,11 +31,11 @@ export const IteratorSymbol: unique symbol = Symbol("codemode.iterator")
 export const IteratorSymbols = [AsyncIteratorSymbol, IteratorSymbol] as const

 export class Throw {
-  constructor(readonly value: unknown) {}
+  constructor(readonly value: Value) {}
 }

 export class GeneratorReturn {
-  constructor(readonly value: unknown) {}
+  constructor(readonly value: Value) {}
 }

 export const OptionalShortCircuit: unique symbol = Symbol("codemode.optional-short-circuit")
@@ -83,12 +83,10 @@ export const unsupportedSyntax = (kind: string, node: AstNode): PendingThrow =>
    [supportedSyntaxMessage],
  )

-export const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null
-
+// Acorn lines are 1-based and its columns are 0-based. Diagnostics use 1-based columns of the submitted source.
 export const sourceLocation = (node: AstNode): { readonly line: number; readonly column: number } => ({
-  line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
-  column: Math.max(1, (node.loc?.start.column ?? 4) - 3),
+  line: node.loc?.start.line ?? 1,
+  column: (node.loc?.start.column ?? 0) + 1,
 })

 export const formatLocation = (node?: AstNode): string => {
@@ -1,18 +1,18 @@
 import { Effect } from "effect"
 import type { Builtins } from "./intrinsics.js"
 import { typeError } from "./model.js"
-import { type Callable, define, frozen, hidden, Native, type NativeOptions, Obj } from "./objects.js"
+import { type Callable, define, frozen, hidden, Native, type NativeOptions, Obj, type Value } from "./objects.js"
 import { describeValue } from "./references.js"

-/** A native function body: a plain value, a thrown `PendingThrow`, or an Effect. */
-export type Impl = (thisValue: unknown, args: Array<unknown>) => unknown
+/** A native function body: a value, a thrown `PendingThrow`, or an Effect of a value. */
+export type Impl = (thisValue: Value, args: Array<Value>) => Value | Effect.Effect<Value, unknown, unknown>

 // The dispatch in `Frame.call` suspends every native call, so a synchronous throw here is a defect.
 const lift =
  <R>(impl: Impl) =>
-  (thisValue: unknown, args: Array<unknown>): Effect.Effect<unknown, unknown, R> => {
+  (thisValue: Value, args: Array<Value>): Effect.Effect<Value, unknown, R> => {
    const result = impl(thisValue, args)
-    return Effect.isEffect(result) ? (result as Effect.Effect<unknown, unknown, R>) : Effect.succeed(result)
+    return Effect.isEffect(result) ? (result as Effect.Effect<Value, unknown, R>) : Effect.succeed(result)
  }

 export const native = <R>(builtins: Builtins, options: NativeOptions<R>): Native<R> =>
@@ -27,7 +27,7 @@ export const methods = (builtins: Builtins, target: Obj, table: ReadonlyArray<Me
  for (const [name, length, impl] of table) define(target, name, fn(builtins, name, length, impl), hidden)
 }

-export const constants = (target: Obj, table: Record<string, unknown>): void => {
+export const constants = (target: Obj, table: Record<string, Value>): void => {
  for (const [name, value] of Object.entries(table)) define(target, name, value, frozen)
 }

@@ -54,7 +54,7 @@ export const prototypeFrom = (newTarget: Callable, fallback: Obj): Obj => {
 /** Narrows a method receiver to the built-in it belongs to, or throws the TypeError JS would. */
 export const receiver = <T extends Obj>(
  cls: abstract new (...args: never) => T,
-  thisValue: unknown,
+  thisValue: Value,
  method: string,
 ): T => {
  if (thisValue instanceof cls) return thisValue
@@ -1,5 +1,7 @@
 import type { BlockStatement, Expression, Pattern } from "acorn"
-import type { Effect, Fiber } from "effect"
+import { Effect, type Fiber } from "effect"
+import { ToolReference } from "../tool-runtime.js"
+import type { Builtins } from "./intrinsics.js"
 import { checkArrayLength } from "./limits.js"
 import {
  AsyncIteratorSymbol,
@@ -16,12 +18,12 @@ export type Attributes = {
  readonly configurable: boolean
 }

-export type Getter = (receiver: unknown) => unknown
-export type Setter = (receiver: unknown, value: unknown) => void
+export type Getter = (receiver: Value) => Value
+export type Setter = (receiver: Value, value: Value) => void

 /** One own property: a data slot or a native accessor pair. */
 export type Slot =
-  | { value: unknown; writable: boolean; enumerable: boolean; configurable: boolean }
+  | { value: Value; writable: boolean; enumerable: boolean; configurable: boolean }
  | { get: Getter | undefined; set: Setter | undefined; enumerable: boolean; configurable: boolean }

 /** Ordinary assignment: writable, enumerable, configurable. */
@@ -33,33 +35,122 @@ export const readonly: Attributes = { writable: false, enumerable: false, config
 /** Constants such as `Math.PI` and a constructor's `prototype`. */
 export const frozen: Attributes = { writable: false, enumerable: false, configurable: false }

-/** An object owned by the program: own properties plus a prototype link. */
+/**
+ * An object owned by the program: own properties plus a prototype link. Subclasses answer, in one place, how a
+ * built-in kind of object prints, coerces, iterates, and crosses to the host.
+ */
 export class Obj {
  readonly props = new Map<string | symbol, Slot>()
  constructor(public proto: Obj | null) {}
+
+  /** The class name `Object.prototype.toString` reports: `[object Map]`. */
+  readonly tag: string = "Object"
+
+  /** How diagnostics refer to a value of this kind. */
+  get describe(): string {
+    if (this.tag === "Object") return "a data object"
+    return `${/^[AEIO]/.test(this.tag) ? "an" : "a"} ${this.tag}`
+  }
+
+  /** ToString without consulting program-defined methods. */
+  toString(): string {
+    return `[object ${this.tag}]`
+  }
+
+  /** ToPrimitive without consulting program-defined methods: only a Date answers a number hint differently. */
+  toPrimitive(hint: "default" | "number" | "string"): string | number {
+    return this.toString()
+  }
+
+  /** ToNumber without consulting program-defined methods. */
+  toNumber(): number {
+    return Number(this.toPrimitive("number"))
+  }
+
+  /** How `console.log` shows the value; `item` formats a child with cycle and depth tracking. */
+  inspect(item: (value: Value) => string): string {
+    return `{${entries(this)
+      .map(([key, value]) => `${JSON.stringify(key)}:${item(value)}`)
+      .join(",")}}`
+  }
+
+  /** A copy the host can hold; `item` converts a child. A `__proto__` key never reaches host code. */
+  toHost(item: (value: Value) => unknown): unknown {
+    return Object.fromEntries(
+      entries(this)
+        .filter(([key]) => key !== "__proto__")
+        .map(([key, value]) => [key, item(value)]),
+    )
+  }
+
+  /** The built-in iteration `for...of` and spread use, when this kind of object has one. */
+  iterator(builtins: Builtins): Iterator<Value, undefined> | undefined {
+    return undefined
+  }
 }

 export class Arr extends Obj {
+  override readonly tag = "Array"
  constructor(
    proto: Obj,
-    readonly items: Array<unknown> = [],
+    readonly items: Array<Value> = [],
  ) {
    super(proto)
  }
+  override get describe() {
+    return "an array"
+  }
+  override toString() {
+    return this.items.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",")
+  }
+  override inspect(item: (value: Value) => string) {
+    return `[${this.items.map(item).join(",")}]`
+  }
+  override toHost(item: (value: Value) => unknown) {
+    return this.items.map(item)
+  }
+  override iterator() {
+    return this.items.values()
+  }
 }

 /** An object with the [[ErrorData]] slot: what `Error.prototype.toString` and the host boundary recognize as an error. */
 export class ErrorObj extends Obj {
+  override readonly tag = "Error"
  /** The interpreter failure this error materialized from, so rethrowing it keeps the diagnostic kind and location. */
  host?: PendingThrow
+  /** Error.prototype.toString: "name: message", or just one when the other is empty. */
+  override toString() {
+    const name = get(this, "name")
+    const message = get(this, "message")
+    const shownName = typeof name === "string" ? name : "Error"
+    const shownMessage = typeof message === "string" ? message : ""
+    if (shownMessage === "") return shownName
+    if (shownName === "") return shownMessage
+    return `${shownName}: ${shownMessage}`
+  }
+  override inspect() {
+    return this.toString()
+  }
 }

-export abstract class Callable extends Obj {
+/** Interpreter machinery a program can hold but never inspect, serialize, or hand to the host. */
+export abstract class Opaque extends Obj {
+  override inspect() {
+    return "[opaque reference]"
+  }
+}
+
+export abstract class Callable extends Opaque {
+  override readonly tag = "Function"
  constructor(proto: Obj, name: string, length: number) {
    super(proto)
    define(this, "length", length, readonly)
    define(this, "name", name, readonly)
  }
+  override get describe() {
+    return "a function"
+  }
 }

 export class Fn extends Callable {
@@ -77,8 +168,8 @@ export class Fn extends Callable {
  }
 }

-export type NativeCall<R> = (thisValue: unknown, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>
-export type NativeConstruct<R> = (args: Array<unknown>, newTarget: Callable) => Effect.Effect<unknown, unknown, R>
+export type NativeCall<R> = (thisValue: Value, args: Array<Value>) => Effect.Effect<Value, unknown, R>
+export type NativeConstruct<R> = (args: Array<Value>, newTarget: Callable) => Effect.Effect<Value, unknown, R>

 export type NativeOptions<R> = {
  readonly name: string
@@ -103,79 +194,182 @@ export class Native<R = never> extends Callable {
  }
 }

-export class PromiseObj extends Obj {
+export class PromiseObj extends Opaque {
+  override readonly tag = "Promise"
  constructor(
    proto: Obj,
-    readonly fiber: Fiber.Fiber<unknown, unknown>,
+    readonly fiber: Fiber.Fiber<Value, unknown>,
  ) {
    super(proto)
  }
+  override get describe() {
+    return "an un-awaited Promise"
+  }
+  override inspect() {
+    return "[Promise (await it to get its value)]"
+  }
 }

-export class GeneratorObj extends Obj {
+export class GeneratorObj extends Opaque {
+  override readonly tag = "Generator"
  constructor(
    proto: Obj,
    readonly asynchronous: boolean,
-    readonly request: (kind: GeneratorRequestKind, value: unknown) => Effect.Effect<unknown, unknown, unknown>,
+    readonly request: (kind: GeneratorRequestKind, value: Value) => Effect.Effect<Value, unknown, unknown>,
  ) {
    super(proto)
  }
+  override get describe() {
+    return "a generator"
+  }
 }

-/** A built-in collection iterator: live over the host collection, yielding program values. */
-export class IteratorObj extends Obj {
+/** One pull from an iterator, as `for...of` sees it. */
+export type Step = { readonly done: boolean; readonly value: Value }
+
+/** How the interpreter drives any iterator: pull the next step, or close it early. */
+export type Cursor<R = unknown> = {
+  readonly next: Effect.Effect<Step, unknown, R>
+  readonly close: Effect.Effect<void, unknown, R>
+}
+
+/** A cursor over a host iterator; there is nothing to close. */
+export const hostCursor = (iterator: Iterator<Value, undefined>): Cursor<never> => ({
+  next: Effect.sync(() => {
+    const step = iterator.next()
+    return { done: Boolean(step.done), value: step.value }
+  }),
+  close: Effect.void,
+})
+
+/** A built-in iterator: a live cursor over a host collection or an iterator helper, yielding program values. */
+export class IteratorObj extends Opaque {
+  override readonly tag = "Iterator"
  constructor(
    proto: Obj,
-    readonly iterator: IteratorObject<unknown>,
+    readonly cursor: Cursor,
  ) {
    super(proto)
  }
+  override get describe() {
+    return "an iterator"
+  }
 }

-export class DateObj extends Obj {
+/** A built-in iterator over a host iterator, e.g. `array.values()`. */
+export const hostIterator = (builtins: Builtins, iterator: Iterator<Value, undefined>): IteratorObj =>
+  new IteratorObj(builtins.Iterator, hostCursor(iterator))
+
+/** A built-in object around a host value: data-like, so it prints as itself and crosses to extensions as a copy. */
+export abstract class Wrapper extends Obj {
+  override inspect(item: (value: Value) => string) {
+    return this.toString()
+  }
+}
+
+export class DateObj extends Wrapper {
+  override readonly tag = "Date"
  constructor(
    proto: Obj,
    public time: number,
  ) {
    super(proto)
  }
+  override toString() {
+    return Number.isFinite(this.time) ? new Date(this.time).toISOString() : "Invalid Date"
+  }
+  override toPrimitive(hint: "default" | "number" | "string") {
+    return hint === "number" ? this.time : this.toString()
+  }
+  override toHost() {
+    return new Date(this.time)
+  }
 }

-export class RegExpObj extends Obj {
+export class RegExpObj extends Wrapper {
+  override readonly tag = "RegExp"
  readonly regex: RegExp
  constructor(proto: Obj, pattern: string, flags: string) {
    super(proto)
    this.regex = new RegExp(pattern, flags)
  }
+  override toString() {
+    return `/${this.regex.source}/${this.regex.flags}`
+  }
+  override toHost() {
+    return new RegExp(this.regex.source, this.regex.flags)
+  }
 }

-export class MapObj extends Obj {
-  readonly map = new Map<unknown, unknown>()
+export class MapObj extends Wrapper {
+  override readonly tag = "Map"
+  readonly map = new Map<Value, Value>()
+  override inspect(item: (value: Value) => string) {
+    return `Map(${this.map.size}) [${[...this.map].map(([key, value]) => `[${item(key)},${item(value)}]`).join(",")}]`
+  }
+  override toHost(item: (value: Value) => unknown) {
+    return new Map([...this.map].map(([key, value]) => [item(key), item(value)]))
+  }
+  override iterator(builtins: Builtins) {
+    return this.map.entries().map((entry) => new Arr(builtins.Array, entry))
+  }
 }

-export class SetObj extends Obj {
-  readonly set = new Set<unknown>()
+export class SetObj extends Wrapper {
+  override readonly tag = "Set"
+  readonly set = new Set<Value>()
+  override inspect(item: (value: Value) => string) {
+    return `Set(${this.set.size}) [${[...this.set].map(item).join(",")}]`
+  }
+  override toHost(item: (value: Value) => unknown) {
+    return new Set([...this.set].map(item))
+  }
+  override iterator() {
+    return this.set.values()
+  }
 }

-export class URLSearchParamsObj extends Obj {
+export class URLSearchParamsObj extends Wrapper {
+  override readonly tag = "URLSearchParams"
  constructor(
    proto: Obj,
    readonly params: URLSearchParams,
  ) {
    super(proto)
  }
+  override toString() {
+    return this.params.toString()
+  }
+  override toHost() {
+    return new URLSearchParams(this.params)
+  }
+  override iterator(builtins: Builtins) {
+    return this.params.entries().map((entry) => new Arr(builtins.Array, entry))
+  }
 }

-export class HeadersObj extends Obj {
+export class HeadersObj extends Wrapper {
+  override readonly tag = "Headers"
  constructor(
    proto: Obj,
    readonly headers: Headers,
  ) {
    super(proto)
  }
+  override inspect() {
+    return `Headers ${JSON.stringify(Object.fromEntries(this.headers))}`
+  }
+  override toHost() {
+    return new Headers(this.headers)
+  }
+  override iterator(builtins: Builtins) {
+    // Bun's Headers typings lack the iterator helpers, so the host iterator is lifted first.
+    return Iterator.from(this.headers.entries()).map((entry) => new Arr(builtins.Array, entry))
+  }
 }

-export class URLObj extends Obj {
+export class URLObj extends Wrapper {
+  override readonly tag = "URL"
  readonly searchParams: URLSearchParamsObj
  constructor(
    proto: Obj,
@@ -185,30 +379,52 @@ export class URLObj extends Obj {
    super(proto)
    this.searchParams = new URLSearchParamsObj(searchParamsProto, url.searchParams)
  }
+  override toString() {
+    return this.url.href
+  }
+  override toHost() {
+    return new URL(this.url.href)
+  }
 }

 /** A `Uint8Array`: the host array does the byte clamping and ignores out-of-range writes, as JS does. */
-export class Bytes extends Obj {
+export class Bytes extends Wrapper {
+  override readonly tag = "Uint8Array"
  constructor(
    proto: Obj,
    readonly bytes: Uint8Array,
  ) {
    super(proto)
  }
+  override toString() {
+    return this.bytes.join(",")
+  }
+  override inspect() {
+    return `Uint8Array(${this.bytes.length}) [${this.bytes.join(",")}]`
+  }
+  override toHost() {
+    return new Uint8Array(this.bytes)
+  }
+  override iterator() {
+    return this.bytes.values()
+  }
 }

-/** Built-in objects that wrap a host value; data-like, but never plain data. */
-export const isWrapper = (
-  value: unknown,
-): value is DateObj | RegExpObj | MapObj | SetObj | URLObj | URLSearchParamsObj | HeadersObj | Bytes =>
-  value instanceof DateObj ||
-  value instanceof RegExpObj ||
-  value instanceof MapObj ||
-  value instanceof SetObj ||
-  value instanceof URLObj ||
-  value instanceof URLSearchParamsObj ||
-  value instanceof HeadersObj ||
-  value instanceof Bytes
+/** Every value a program can hold. Host values never appear here; they are copied in at the boundaries. */
+export type Value = string | number | boolean | null | undefined | symbol | Obj | ToolReference
+
+/** ToString without consulting program-defined methods. */
+export const coerceToString = (value: Value): string => (value instanceof Obj ? value.toString() : String(value))
+
+/** ToNumber without consulting program-defined methods; tool references are not numbers. */
+export const coerceToNumber = (value: Value): number => {
+  if (value instanceof Obj) return value.toNumber()
+  return value instanceof ToolReference ? Number.NaN : Number(value)
+}
+
+/** Values that cannot cross the data boundary: opaque machinery and host-backed wrappers. */
+export const isRuntimeReference = (value: Value): boolean =>
+  value instanceof Opaque || value instanceof Wrapper || value instanceof ToolReference

 const MAX_ARRAY_INDEX = 4_294_967_295

@@ -226,7 +442,7 @@ type Indexed = Arr | Bytes

 const isIndexed = (target: Obj): target is Indexed => target instanceof Arr || target instanceof Bytes

-const elements = (target: Indexed): Array<unknown> | Uint8Array => (target instanceof Arr ? target.items : target.bytes)
+const elements = (target: Indexed): Array<Value> | Uint8Array => (target instanceof Arr ? target.items : target.bytes)

 const index = (target: Obj, key: string | symbol): number | undefined =>
  isIndexed(target) && typeof key === "string" ? parseArrayIndex(key) : undefined
@@ -247,18 +463,18 @@ export const own = (target: Obj, key: PropertyKey): Slot | undefined => {
  return target.props.get(name)
 }

-const read = (slot: Slot, receiver: unknown): unknown =>
+const read = (slot: Slot, receiver: Value): Value =>
  "value" in slot ? slot.value : slot.get === undefined ? undefined : slot.get(receiver)

 export const hasOwn = (target: Obj, key: PropertyKey): boolean => own(target, key) !== undefined

-export const getOwn = (target: Obj, key: PropertyKey): unknown => {
+export const getOwn = (target: Obj, key: PropertyKey): Value => {
  const slot = own(target, key)
  return slot === undefined ? undefined : read(slot, target)
 }

 /** [[Get]]: walks the prototype chain; accessors see `receiver`, which is the primitive for wrapper prototypes. */
-export const get = (target: Obj, key: PropertyKey, receiver: unknown = target): unknown => {
+export const get = (target: Obj, key: PropertyKey, receiver: Value = target): Value => {
  for (let current: Obj | null = target; current !== null; current = current.proto) {
    const slot = own(current, key)
    if (slot !== undefined) return read(slot, receiver)
@@ -273,14 +489,14 @@ export const has = (target: Obj, key: PropertyKey): boolean => {
  return false
 }

-export const hasPrototype = (value: unknown, proto: Obj): boolean => {
+export const hasPrototype = (value: Value, proto: Obj): boolean => {
  for (let current = value instanceof Obj ? value.proto : null; current !== null; current = current.proto) {
    if (current === proto) return true
  }
  return false
 }

-const writeElement = (target: Indexed, name: string | symbol, value: unknown): boolean | undefined => {
+const writeElement = (target: Indexed, name: string | symbol, value: Value): boolean | undefined => {
  const at = index(target, name)
  if (at !== undefined) {
    if (target instanceof Bytes) target.bytes[at] = typeof value === "number" ? value : Number(value)
@@ -296,7 +512,7 @@ const writeElement = (target: Indexed, name: string | symbol, value: unknown): b
 }

 /** [[Set]]: an inherited setter or read-only property decides before an own data property is created. */
-export const set = (target: Obj, key: PropertyKey, value: unknown): boolean => {
+export const set = (target: Obj, key: PropertyKey, value: Value): boolean => {
  const name = canonical(key)
  for (let current: Obj | null = target; current !== null; current = current.proto) {
    const slot = own(current, name)
@@ -324,7 +540,7 @@ export const set = (target: Obj, key: PropertyKey, value: unknown): boolean => {
 }

 /** [[DefineOwnProperty]] for a data property, ignoring the chain. */
-export const define = (target: Obj, key: PropertyKey, value: unknown, attrs: Attributes = data): void => {
+export const define = (target: Obj, key: PropertyKey, value: Value, attrs: Attributes = data): void => {
  const name = canonical(key)
  if (isIndexed(target) && writeElement(target, name, value) !== undefined) return
  target.props.set(name, { value, ...attrs })
@@ -375,9 +591,9 @@ export const keys = (target: Obj): Array<string> =>
  ownKeys(target).filter((key): key is string => typeof key === "string" && enumerable(target, key))

 /** Own enumerable string entries: `Object.entries` and serialization. */
-export const entries = (target: Obj): Array<[string, unknown]> => keys(target).map((key) => [key, getOwn(target, key)])
+export const entries = (target: Obj): Array<[string, Value]> => keys(target).map((key) => [key, getOwn(target, key)])

-export const record = (proto: Obj, fields: Record<string, unknown>): Obj => {
+export const record = (proto: Obj, fields: Record<string, Value>): Obj => {
  const target = new Obj(proto)
  for (const [key, value] of Object.entries(fields)) define(target, key, value)
  return target
@@ -2,15 +2,15 @@ import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect"
 import type { Diagnostic } from "../codemode.js"
 import { MAX_PENDING_PROMISES } from "./limits.js"
 import { CallSite, Throw, rangeError, typeError } from "./model.js"
-import { Callable, define, get, hidden, Arr, Fn, Obj, PromiseObj, record } from "./objects.js"
+import { Callable, define, get, hidden, Arr, Fn, Obj, PromiseObj, record, type Value } from "./objects.js"
 import { constructor, fn, methods, native, receiver, requiresNew } from "./native.js"
 import { createAggregateErrorValue, locate, materialize, normalizeError } from "./errors.js"
-import { typeofValue } from "./references.js"
+import { describeValue, typeofValue } from "./references.js"
 import { applyCollectionCallback, isSupportedCallback } from "./callback.js"
 import type { Interpreter } from "./interpreter.js"

 // A `resolve`/`reject` handed to an executor or thenable: calling it settles the capability.
-const capability = <R>(ctx: Interpreter<R>, name: string, settle: (value: unknown) => void) =>
+const capability = <R>(ctx: Interpreter<R>, name: string, settle: (value: Value) => void) =>
  fn(ctx.builtins, name, 1, (_, args) => {
    settle(args[0])
    return undefined
@@ -31,7 +31,7 @@ export class Pending<R> {

  // Resolution bodies need the promise's own identity to reject `resolve(promise)` self-resolution.
  createWithSelf(
-    body: (self: { promise?: PromiseObj }) => Effect.Effect<unknown, unknown, R>,
+    body: (self: { promise?: PromiseObj }) => Effect.Effect<Value, unknown, R>,
  ): Effect.Effect<PromiseObj, never, R> {
    const self: { promise?: PromiseObj } = {}
    return Effect.map(this.create(body(self)), (promise) => {
@@ -40,7 +40,7 @@ export class Pending<R> {
    })
  }

-  create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<PromiseObj, never, R> {
+  create(effect: Effect.Effect<Value, unknown, R>): Effect.Effect<PromiseObj, never, R> {
    return Effect.flatMap(CallSite, (site) => {
      if (this.active.size >= MAX_PENDING_PROMISES) {
        throw rangeError(
@@ -79,7 +79,7 @@ export class Pending<R> {
    if (id !== undefined) this.failures.delete(id)
  }

-  await(promise: PromiseObj): Effect.Effect<Exit.Exit<unknown, unknown>> {
+  await(promise: PromiseObj): Effect.Effect<Exit.Exit<Value, unknown>> {
    return Fiber.await(promise.fiber)
  }

@@ -105,9 +105,9 @@ export class Pending<R> {

 export const resolvePromiseValue = <R>(
  ctx: Interpreter<R>,
-  value: unknown,
+  value: Value,
  own?: { promise?: PromiseObj },
-): Effect.Effect<unknown, unknown, R> => {
+): Effect.Effect<Value, unknown, R> => {
  if (own?.promise !== undefined && value === own.promise) {
    return Effect.die(typeError("Chaining cycle detected: a promise cannot resolve with itself."))
  }
@@ -119,7 +119,7 @@ export const resolvePromiseValue = <R>(
  return Effect.gen(function* () {
    // Promise resolution invokes a thenable's method in a later job.
    yield* Effect.yieldNow
-    const deferred = Deferred.makeUnsafe<unknown, unknown>()
+    const deferred = Deferred.makeUnsafe<Value, unknown>()
    const resolve = capability(ctx, "resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)))
    const reject = capability(ctx, "reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new Throw(reason))))
    const executed = yield* Effect.exit(ctx.call(then, value, [resolve, reject]))
@@ -131,29 +131,46 @@ export const resolvePromiseValue = <R>(
  })
 }

-export const resolvePromise = <R>(ctx: Interpreter<R>, value: unknown): Effect.Effect<PromiseObj, never, R> => {
+export const resolvePromise = <R>(ctx: Interpreter<R>, value: Value): Effect.Effect<PromiseObj, never, R> => {
  if (value instanceof PromiseObj) return Effect.succeed(value)
  return ctx.pending.createWithSelf((self) => resolvePromiseValue(ctx, value, self))
 }

-const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"] as const
+const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject", "withResolvers", "try"] as const

 const invokePromiseMethod = <R>(
  ctx: Interpreter<R>,
  name: (typeof promiseStatics)[number],
-  args: Array<unknown>,
-): Effect.Effect<unknown, unknown, R> => {
+  args: Array<Value>,
+): Effect.Effect<Value, unknown, R> => {
  if (name === "resolve") {
    return resolvePromise(ctx, args[0])
  }
  if (name === "reject") {
    return ctx.pending.create(Effect.fail(new Throw(args[0])))
  }
+  if (name === "withResolvers") {
+    return Effect.map(promiseCapability(ctx), (made) =>
+      record(ctx.builtins.Object, { promise: made.promise, resolve: made.resolve, reject: made.reject }),
+    )
+  }
+  if (name === "try") {
+    if (typeofValue(args[0]) !== "function") {
+      throw typeError(`Promise.try expects a function, received ${describeValue(args[0])}.`)
+    }
+    return Effect.flatMap(Effect.exit(ctx.call(args[0], undefined, args.slice(1))), (called) => {
+      if (Exit.isSuccess(called)) return resolvePromise(ctx, called.value)
+      if (Cause.hasInterruptsOnly(called.cause)) return Effect.failCause(called.cause)
+      return ctx.pending.create(Effect.fail(Cause.squash(called.cause)))
+    })
+  }

  return ctx.pending.create(
    Effect.gen(function* () {
      const cursor = yield* ctx.iterate(args[0])
-      if (cursor === undefined) throw typeError(`Promise.${name} expects an array or other synchronous iterable.`)
+      if (cursor === undefined) {
+        throw typeError(`Promise.${name} expects a synchronous iterable, received ${describeValue(args[0])}.`)
+      }
      const items: Array<PromiseObj> = []
      while (true) {
        const step = yield* cursor.next
@@ -175,7 +192,7 @@ const invokePromiseMethod = <R>(
        )
      }
      if (name === "allSettled") {
-        const outcomes: Array<unknown> = []
+        const outcomes: Array<Value> = []
        for (const item of items) {
          const exit = yield* ctx.pending.await(item)
          if (Exit.isSuccess(exit)) {
@@ -223,8 +240,8 @@ const invokePromiseMethod = <R>(
 const instanceMethod = <R>(
  ctx: Interpreter<R>,
  name: "then" | "catch" | "finally",
-  thisValue: unknown,
-  args: Array<unknown>,
+  thisValue: Value,
+  args: Array<Value>,
 ): Effect.Effect<PromiseObj, unknown, R> => {
  const method = `Promise.prototype.${name}`
  const promise = receiver(PromiseObj, thisValue, method)
@@ -237,23 +254,30 @@ const instanceMethod = <R>(
  return chainReaction(ctx, promise, onFulfilled, onRejected, method)
 }

-const constructPromise = <R>(ctx: Interpreter<R>, executor: unknown): Effect.Effect<PromiseObj, unknown, R> => {
-  if (!(executor instanceof Fn)) {
-    throw typeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).")
-  }
-  return Effect.gen(function* () {
-    const deferred = Deferred.makeUnsafe<unknown, unknown>()
+/** NewPromiseCapability: a pending promise with the resolve/reject callables that settle it exactly once. */
+const promiseCapability = <R>(ctx: Interpreter<R>) =>
+  Effect.gen(function* () {
+    const deferred = Deferred.makeUnsafe<Value, unknown>()
    const promise = yield* ctx.pending.createWithSelf((self) =>
      Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(ctx, value, self)),
    )
    const resolve = capability(ctx, "resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)))
    const reject = capability(ctx, "reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new Throw(value))))
-    const executed = yield* Effect.exit(ctx.call(executor, undefined, [resolve, reject]))
+    return { promise, resolve, reject, deferred }
+  })
+
+const constructPromise = <R>(ctx: Interpreter<R>, executor: Value): Effect.Effect<PromiseObj, unknown, R> => {
+  if (!(executor instanceof Fn)) {
+    throw typeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).")
+  }
+  return Effect.gen(function* () {
+    const made = yield* promiseCapability(ctx)
+    const executed = yield* Effect.exit(ctx.call(executor, undefined, [made.resolve, made.reject]))
    if (!Exit.isSuccess(executed)) {
      if (Cause.hasInterruptsOnly(executed.cause)) return yield* Effect.failCause(executed.cause)
-      Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)))
+      Deferred.doneUnsafe(made.deferred, Exit.fail(Cause.squash(executed.cause)))
    }
-    return promise
+    return made.promise
  })
 }

@@ -262,10 +286,10 @@ const settleAfterTurn = <A, E, R>(body: Effect.Effect<A, E, R>): Effect.Effect<A
  Effect.flatMap(Effect.exit(body), (exit) => Effect.andThen(Effect.yieldNow, exit))

 class PromiseAnyFulfilled {
-  constructor(readonly value: unknown) {}
+  constructor(readonly value: Value) {}
 }

-const reactionHandler = (value: unknown, method: string): Callable | undefined => {
+const reactionHandler = (value: Value, method: string): Callable | undefined => {
  if (isSupportedCallback(value)) return value
  if (typeofValue(value) === "function") {
    throw typeError(
@@ -279,7 +303,7 @@ const reactionHandler = (value: unknown, method: string): Callable | undefined =
 const reactionExit = <R>(
  ctx: Interpreter<R>,
  source: PromiseObj,
-): Effect.Effect<Exit.Exit<unknown, unknown>, unknown, R> =>
+): Effect.Effect<Exit.Exit<Value, unknown>, unknown, R> =>
  Effect.gen(function* () {
    const exit = yield* ctx.pending.await(source)
    if (!Exit.isSuccess(exit) && Cause.hasInterruptsOnly(exit.cause)) return yield* Effect.failCause(exit.cause)
@@ -1,47 +1,18 @@
 import { ToolReference } from "../tool-runtime.js"
 import { invalidData } from "./model.js"
-import {
-  Callable,
-  getOwn,
-  isWrapper,
-  ownKeys,
-  Arr,
-  Bytes,
-  DateObj,
-  GeneratorObj,
-  IteratorObj,
-  MapObj,
-  Obj,
-  PromiseObj,
-  RegExpObj,
-  SetObj,
-  URLObj,
-  URLSearchParamsObj,
-  HeadersObj,
-} from "./objects.js"
+import { Callable, getOwn, isRuntimeReference, Obj, Opaque, ownKeys, type Value } from "./objects.js"

-/** Values that cannot cross the data boundary. */
-export const isRuntimeReference = (value: unknown): boolean =>
-  value instanceof Callable ||
-  value instanceof GeneratorObj ||
-  value instanceof IteratorObj ||
-  value instanceof ToolReference ||
-  value instanceof PromiseObj ||
-  isWrapper(value)
-
-function* childValues(value: object): Generator {
-  if (!(value instanceof Obj)) return
-  for (const key of ownKeys(value)) yield getOwn(value, key)
-}
+/** Interpreter machinery that is never data, unlike a Date or Map, which cross some boundaries as copies. */
+export const isOpaque = (value: Value): boolean => value instanceof Opaque || value instanceof ToolReference

 // Depth-first search over a value tree. `match` stops the walk; `skip` prunes a subtree without matching it.
 const find = (
-  value: unknown,
-  match: (current: unknown) => boolean,
-  skip: (current: unknown) => boolean,
+  value: Value,
+  match: (current: Value) => boolean,
+  skip: (current: Value) => boolean,
  seen: Set<object>,
 ): boolean => {
-  const pending: Array<Iterator<unknown>> = [[value].values()]
+  const pending: Array<Iterator<Value>> = [[value].values()]
  while (pending.length > 0) {
    const next = pending.at(-1)!.next()
    if (next.done) {
@@ -50,25 +21,28 @@ const find = (
    }
    const current = next.value
    if (match(current)) return true
-    if (current === null || typeof current !== "object" || skip(current) || seen.has(current)) continue
+    if (!(current instanceof Obj) || skip(current) || seen.has(current)) continue
    seen.add(current)
-    pending.push(childValues(current))
+    pending.push(
+      ownKeys(current)
+        .map((key) => getOwn(current, key))
+        .values(),
+    )
  }
  return false
 }

 const never = () => false

-export const containsRuntimeReference = (value: unknown): boolean => find(value, isRuntimeReference, never, new Set())
+export const containsRuntimeReference = (value: Value): boolean => find(value, isRuntimeReference, never, new Set())

-// Wrapper values are data here, not opaque interpreter references.
-export const containsOpaqueReference = (value: unknown): boolean =>
-  find(value, (current) => !isWrapper(current) && isRuntimeReference(current), isWrapper, new Set())
+export const containsOpaqueReference = (value: Value): boolean =>
+  find(value, isOpaque, (current) => isRuntimeReference(current) && !isOpaque(current), new Set())

 // Reject cycles before mutation so later boundary walks remain safe.
 export const rejectCircularInsertion = (
-  container: object,
-  value: unknown,
+  container: Obj,
+  value: Value,
  label: string,
  seen = new Set<object>(),
 ): void => {
@@ -77,27 +51,14 @@ export const rejectCircularInsertion = (
  }
 }

-export const describeValue = (value: unknown): string => {
+export const describeValue = (value: Value): string => {
  if (value === null || value === undefined) return String(value)
-  if (value instanceof Arr) return "an array"
-  if (value instanceof PromiseObj) return "an un-awaited Promise"
+  if (value instanceof Obj) return value.describe
  if (value instanceof ToolReference) return "a tool reference"
-  if (value instanceof DateObj) return "a Date"
-  if (value instanceof RegExpObj) return "a RegExp"
-  if (value instanceof MapObj) return "a Map"
-  if (value instanceof SetObj) return "a Set"
-  if (value instanceof URLObj) return "a URL"
-  if (value instanceof URLSearchParamsObj) return "a URLSearchParams"
-  if (value instanceof HeadersObj) return "a Headers"
-  if (value instanceof Bytes) return "a Uint8Array"
-  if (value instanceof GeneratorObj) return "a generator"
-  if (value instanceof IteratorObj) return "an iterator"
-  if (isRuntimeReference(value)) return "a function"
-  if (typeof value === "object") return "a data object"
  return `a ${typeof value}`
 }

-export const typeofValue = (value: unknown): string => {
+export const typeofValue = (value: Value): string => {
  if (value instanceof Callable) return "function"
  if (value instanceof ToolReference) return value.path.length > 0 ? "function" : "object"
  return typeof value
@@ -1,4 +1,5 @@
 import { type AstNode, type Binding, referenceError, typeError } from "./model.js"
+import type { Value } from "./objects.js"

 export class ScopeStack {
  private readonly scopes: Array<Map<string, Binding>>
@@ -15,7 +16,7 @@ export class ScopeStack {
    scope.set(name, { mutable, value: undefined, initialized: false })
  }

-  initialize(name: string, value: unknown, node: AstNode): void {
+  initialize(name: string, value: Value, node: AstNode): void {
    const binding = this.current().get(name)
    if (!binding || binding.initialized !== false) {
      throw typeError(`Identifier '${name}' has not been reserved for initialization.`, node)
@@ -24,7 +25,7 @@ export class ScopeStack {
    binding.initialized = true
  }

-  declare(name: string, value: unknown, mutable: boolean, node: AstNode): void {
+  declare(name: string, value: Value, mutable: boolean, node: AstNode): void {
    const scope = this.current()
    if (scope.has(name)) {
      throw typeError(`Identifier '${name}' has already been declared.`, node)
@@ -32,7 +33,7 @@ export class ScopeStack {
    scope.set(name, { mutable, value, initialized: true })
  }

-  get(name: string, node: AstNode): unknown {
+  get(name: string, node: AstNode): Value {
    const binding = this.resolve(name)

    if (!binding) {
@@ -46,7 +47,7 @@ export class ScopeStack {
    return binding.value
  }

-  set(name: string, value: unknown, node: AstNode): unknown {
+  set(name: string, value: Value, node: AstNode): Value {
    const binding = this.resolve(name)

    if (!binding) {
@@ -2,26 +2,34 @@ import { Effect } from "effect"
 import { constructor, type Method, methods, prototypeFrom, receiver } from "../interpreter/native.js"
 import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interpreter/limits.js"
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js"
-import { define, get, hidden, Arr, GeneratorObj, IteratorObj, Obj } from "../interpreter/objects.js"
+import {
+  define,
+  get,
+  hidden,
+  Arr,
+  GeneratorObj,
+  hostIterator,
+  Obj,
+  coerceToNumber,
+  coerceToString,
+  type Value,
+} from "../interpreter/objects.js"
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js"
-import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js"
+import { applyCollectionCallback, invoke, preserveConsumerError } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
 import { compareText } from "../tool-runtime.js"
-import { coerceToNumber, coerceToString } from "./value.js"

-const arrayLikeSource = (source: unknown): { readonly length: number; readonly source: Obj } => {
+const arrayLikeSource = (source: Value): { readonly length: number; readonly source: Obj } => {
  if (source instanceof Obj && typeof get(source, "length") === "number") {
    const length = get(source, "length") as number
    const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length)
    checkArrayLength(normalized)
    return { length: normalized, source }
  }
-  throw invalidData(
-    `Array.from expects an array, string, Map, Set, or array-like value, received ${describeValue(source)}.`,
-  )
+  throw invalidData(`Array.from expects an iterable or array-like value, received ${describeValue(source)}.`)
 }

-const arrayFrom = <R>(ctx: Interpreter<R>, args: Array<unknown>): Effect.Effect<unknown, unknown, R> => {
+const arrayFrom = <R>(ctx: Interpreter<R>, args: Array<Value>): Effect.Effect<Value, unknown, R> => {
  const source = args[0]
  const proto = ctx.builtins.Array
  const apply =
@@ -30,22 +38,26 @@ const arrayFrom = <R>(ctx: Interpreter<R>, args: Array<unknown>): Effect.Effect<
    const cursor = yield* ctx.iterate(source)
    if (cursor === undefined) {
      if (source instanceof GeneratorObj) {
-        throw typeError("Array.from expects a synchronous iterable or array-like value.")
+        throw typeError(
+          `Array.from expects a synchronous iterable or array-like value, received ${describeValue(source)}.`,
+        )
      }
      const arrayLike = arrayLikeSource(source)
-      const values: Array<unknown> = []
+      const values: Array<Value> = []
      for (let index = 0; index < arrayLike.length; index += 1) {
        const item = get(arrayLike.source, index)
        values.push(apply === undefined ? item : yield* apply([item, index]))
      }
      return new Arr(proto, values)
    }
-    const values: Array<unknown> = []
+    const values: Array<Value> = []
    let index = 0
    while (true) {
      const step = yield* cursor.next
      if (step.done) return new Arr(proto, values)
-      values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor, apply([step.value, index])))
+      values.push(
+        apply === undefined ? step.value : yield* preserveConsumerError(cursor.close, apply([step.value, index])),
+      )
      index += 1
    }
  })
@@ -53,21 +65,21 @@ const arrayFrom = <R>(ctx: Interpreter<R>, args: Array<unknown>): Effect.Effect<

 export const sortArray = <R>(
  ctx: Interpreter<R>,
-  target: Array<unknown>,
-  comparator: unknown,
+  target: Array<Value>,
+  comparator: Value,
  name: string,
-): Effect.Effect<Array<unknown>, unknown, R> => {
+): Effect.Effect<Array<Value>, unknown, R> => {
  if (comparator === undefined) {
    return Effect.sync(() => [...target].sort((a, b) => compareText(coerceToString(a), coerceToString(b))))
  }
  const apply = applyCollectionCallback(ctx, comparator, name)
-  const mergeSort = (items: Array<unknown>): Effect.Effect<Array<unknown>, unknown, R> => {
+  const mergeSort = (items: Array<Value>): Effect.Effect<Array<Value>, unknown, R> => {
    if (items.length <= 1) return Effect.succeed(items)
    const midpoint = Math.floor(items.length / 2)
    return Effect.gen(function* () {
      const left = yield* mergeSort(items.slice(0, midpoint))
      const right = yield* mergeSort(items.slice(midpoint))
-      const merged: Array<unknown> = []
+      const merged: Array<Value> = []
      let leftIndex = 0
      let rightIndex = 0
      while (leftIndex < left.length && rightIndex < right.length) {
@@ -88,8 +100,8 @@ export const sortArray = <R>(
 export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
  const builtins = ctx.builtins
  const proto = builtins.Array
-  const wrap = (items: Array<unknown>) => new Arr(proto, items)
-  const construct = (args: Array<unknown>, into: Obj): Arr => {
+  const wrap = (items: Array<Value>) => new Arr(proto, items)
+  const construct = (args: Array<Value>, into: Obj): Arr => {
    if (args.length !== 1) return new Arr(into, [...args])
    const first = args[0]
    if (typeof first !== "number") return new Arr(into, [first])
@@ -109,8 +121,8 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
    ["from", 1, (_, args) => arrayFrom(ctx, args)],
  ])

-  const self = (thisValue: unknown, name: string) => receiver(Arr, thisValue, `Array.prototype.${name}`)
-  const optNumber = (name: string, value: unknown, label: string): number | undefined => {
+  const self = (thisValue: Value, name: string) => receiver(Arr, thisValue, `Array.prototype.${name}`)
+  const optNumber = (name: string, value: Value, label: string): number | undefined => {
    if (value === undefined) return undefined
    if (typeof value !== "number") {
      throw typeError(`Array.${name} expects ${label} to be a number.`)
@@ -122,11 +134,11 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
    name: string,
    length: number,
    body: (
-      target: Array<unknown>,
+      target: Array<Value>,
      receiver: Arr,
-      apply: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>,
-      args: Array<unknown>,
-    ) => Effect.Effect<unknown, unknown, R>,
+      apply: (args: Array<Value>) => Effect.Effect<Value, unknown, R>,
+      args: Array<Value>,
+    ) => Effect.Effect<Value, unknown, R>,
  ): Method => [
    name,
    length,
@@ -214,7 +226,7 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
      "flat",
      0,
      (thisValue, args) => {
-        const flatten = (items: Array<unknown>, depth: number): Array<unknown> =>
+        const flatten = (items: Array<Value>, depth: number): Array<Value> =>
          items.flatMap((item) => (item instanceof Arr && depth > 0 ? flatten(item.items, depth - 1) : [item]))
        const flattened = flatten(self(thisValue, "flat").items, optNumber("flat", args[0], "depth") ?? 1)
        checkArrayLength(flattened.length)
@@ -340,14 +352,27 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
        return target
      },
    ],
-    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").items.keys())],
-    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").items.values())],
+    [
+      "toLocaleString",
+      0,
+      (thisValue) =>
+        Effect.map(
+          Effect.forEach(self(thisValue, "toLocaleString").items, (item) =>
+            item === null || item === undefined
+              ? Effect.succeed("")
+              : Effect.map(invoke(ctx, item, "toLocaleString", "Array.prototype.toLocaleString"), coerceToString),
+          ),
+          (parts) => parts.join(","),
+        ),
+    ],
+    ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").items.keys())],
+    ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").items.values())],
    [
      "entries",
      0,
      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
+        hostIterator(
+          builtins,
          self(thisValue, "entries")
            .items.entries()
            .map(([index, item]) => wrap([index, item])),
@@ -356,7 +381,7 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
    iterate("map", 1, (target, receiver, apply) =>
      Effect.gen(function* () {
        const length = target.length
-        const values: Array<unknown> = []
+        const values: Array<Value> = []
        values.length = length
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
@@ -368,7 +393,7 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
    iterate("flatMap", 1, (target, receiver, apply) =>
      Effect.gen(function* () {
        const length = target.length
-        const values: Array<unknown> = []
+        const values: Array<Value> = []
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
          const mapped = yield* apply([target[index], index, receiver])
@@ -381,7 +406,7 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
    iterate("filter", 1, (target, receiver, apply) =>
      Effect.gen(function* () {
        const length = target.length
-        const values: Array<unknown> = []
+        const values: Array<Value> = []
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
          const item = target[index]
@@ -2,13 +2,24 @@ import { Effect } from "effect"
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js"
 import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js"
 import { IteratorSymbol, rangeError, syntaxError, typeError } from "../interpreter/model.js"
-import { define, defineAccessor, get, hidden, Arr, Bytes, IteratorObj, Obj } from "../interpreter/objects.js"
+import {
+  define,
+  defineAccessor,
+  get,
+  hidden,
+  Arr,
+  Bytes,
+  hostIterator,
+  Obj,
+  coerceToNumber,
+  coerceToString,
+  type Value,
+} from "../interpreter/objects.js"
 import { describeValue } from "../interpreter/references.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
-import { coerceToNumber, coerceToString } from "./value.js"

 /** The bytes a Uint8Array, array, or other iterable of numbers describes; the host array clamps each value. */
-const collectBytes = <R>(ctx: Interpreter<R>, source: unknown, name: string): Effect.Effect<Uint8Array, unknown, R> => {
+const collectBytes = <R>(ctx: Interpreter<R>, source: Value, name: string): Effect.Effect<Uint8Array, unknown, R> => {
  if (source instanceof Bytes) return Effect.succeed(new Uint8Array(source.bytes))
  return Effect.gen(function* () {
    const cursor = yield* ctx.iterate(source)
@@ -27,7 +38,7 @@ const collectBytes = <R>(ctx: Interpreter<R>, source: unknown, name: string): Ef
  })
 }

-const constructBytes = <R>(ctx: Interpreter<R>, args: Array<unknown>, proto: Obj) => {
+const constructBytes = <R>(ctx: Interpreter<R>, args: Array<Value>, proto: Obj) => {
  const source = args[0]
  if (source !== null && typeof source === "object") {
    return Effect.map(collectBytes(ctx, source, "new Uint8Array(...)"), (bytes) => new Bytes(proto, bytes))
@@ -48,7 +59,7 @@ export const uint8ArrayGlobal = <R>(ctx: Interpreter<R>) => {
    call: requiresNew("Uint8Array"),
    construct: (args, newTarget) => constructBytes(ctx, args, prototypeFrom(newTarget, proto)),
  })
-  const decode = (name: string, args: Array<unknown>, from: (text: string) => Uint8Array) => {
+  const decode = (name: string, args: Array<Value>, from: (text: string) => Uint8Array) => {
    if (typeof args[0] !== "string") throw typeError(`Uint8Array.${name} expects a string.`)
    try {
      return wrap(from(args[0]))
@@ -63,13 +74,13 @@ export const uint8ArrayGlobal = <R>(ctx: Interpreter<R>) => {
    ["fromHex", 1, (_, args) => decode("fromHex", args, (text) => Uint8Array.fromHex(text))],
  ])

-  const self = (thisValue: unknown, name: string) => receiver(Bytes, thisValue, `Uint8Array.prototype.${name}`)
-  const optNumber = (name: string, value: unknown, label: string): number | undefined => {
+  const self = (thisValue: Value, name: string) => receiver(Bytes, thisValue, `Uint8Array.prototype.${name}`)
+  const optNumber = (name: string, value: Value, label: string): number | undefined => {
    if (value === undefined) return undefined
    if (typeof value !== "number") throw typeError(`Uint8Array.${name} expects ${label} to be a number.`)
    return value
  }
-  const wrapAll = (items: Array<unknown>) => new Arr(builtins.Array, items)
+  const wrapAll = (items: Array<Value>) => new Arr(builtins.Array, items)
  defineAccessor(proto, "length", (thisValue) => self(thisValue, "length").bytes.length)
  methods(builtins, proto, [
    ["at", 1, (thisValue, args) => self(thisValue, "at").bytes.at(optNumber("at", args[0], "index") ?? 0)],
@@ -173,14 +184,14 @@ export const uint8ArrayGlobal = <R>(ctx: Interpreter<R>) => {
    ["toString", 0, (thisValue) => self(thisValue, "toString").bytes.join(",")],
    ["toBase64", 0, (thisValue) => self(thisValue, "toBase64").bytes.toBase64()],
    ["toHex", 0, (thisValue) => self(thisValue, "toHex").bytes.toHex()],
-    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").bytes.keys())],
-    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").bytes.values())],
+    ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").bytes.keys())],
+    ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").bytes.values())],
    [
      "entries",
      0,
      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
+        hostIterator(
+          builtins,
          self(thisValue, "entries")
            .bytes.entries()
            .map(([index, byte]) => wrapAll([index, byte])),
@@ -222,8 +233,7 @@ const utf8Labels = new Set(["unicode-1-1-utf-8", "unicode11utf8", "unicode20utf8
 export const textDecoderGlobal = <R>(ctx: Interpreter<R>) => {
  const builtins = ctx.builtins
  const proto = builtins.TextDecoder
-  const self = (thisValue: unknown, name: string) =>
-    receiver(TextDecoderObj, thisValue, `TextDecoder.prototype.${name}`)
+  const self = (thisValue: Value, name: string) => receiver(TextDecoderObj, thisValue, `TextDecoder.prototype.${name}`)
  defineAccessor(proto, "encoding", (thisValue) => self(thisValue, "encoding").decoder.encoding)
  defineAccessor(proto, "fatal", (thisValue) => self(thisValue, "fatal").decoder.fatal)
  defineAccessor(proto, "ignoreBOM", (thisValue) => self(thisValue, "ignoreBOM").decoder.ignoreBOM)
@@ -7,15 +7,17 @@ import {
  get,
  getOwn,
  hidden,
-  isWrapper,
  Arr,
-  IteratorObj,
+  coerceToString,
+  hostCursor,
+  hostIterator,
  MapObj,
  Obj,
  PromiseObj,
  SetObj,
+  type Value,
 } from "../interpreter/objects.js"
-import { describeValue, isRuntimeReference } from "../interpreter/references.js"
+import { describeValue, isOpaque } from "../interpreter/references.js"
 import {
  applyCollectionCallback,
  isSupportedCallback,
@@ -25,9 +27,9 @@ import {
 } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"

-const coerceGroupByPropertyKey = <R>(ctx: Interpreter<R>, value: unknown): Effect.Effect<string, unknown, R> => {
-  if (value instanceof PromiseObj) return Effect.succeed("[object Promise]")
-  if (!isWrapper(value) && isRuntimeReference(value)) {
+const coerceGroupByPropertyKey = <R>(ctx: Interpreter<R>, value: Value): Effect.Effect<string, unknown, R> => {
+  if (value instanceof PromiseObj) return Effect.succeed(coerceToString(value))
+  if (isOpaque(value)) {
    throw invalidData(`Object.groupBy callback must return a data value, received ${describeValue(value)}.`)
  }
  return toPrimitiveString(ctx, value)
@@ -54,7 +56,7 @@ export const groupBy = <R>(ctx: Interpreter<R>, namespace: "Map" | "Object") =>
          const step = yield* cursor.next
          if (step.done) return result
          const item = step.value
-          const key = yield* preserveConsumerError(cursor, apply([item, index]))
+          const key = yield* preserveConsumerError(cursor.close, apply([item, index]))
          const group = result.map.get(key)
          if (group === undefined) result.map.set(key, new Arr(builtins.Array, [item]))
          else (group as Arr).items.push(item)
@@ -70,7 +72,7 @@ export const groupBy = <R>(ctx: Interpreter<R>, namespace: "Map" | "Object") =>
        if (step.done) return result
        const item = step.value
        const key = yield* preserveConsumerError(
-          cursor,
+          cursor.close,
          Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(ctx, value)),
        )
        const group = getOwn(result, key)
@@ -81,19 +83,19 @@ export const groupBy = <R>(ctx: Interpreter<R>, namespace: "Map" | "Object") =>
    })
  })

-const constructMap = <R>(ctx: Interpreter<R>, init: unknown, proto: Obj) => {
+const constructMap = <R>(ctx: Interpreter<R>, init: Value, proto: Obj) => {
  const target = new MapObj(proto)
  if (init === undefined || init === null) return Effect.succeed(target)
  return Effect.gen(function* () {
    const cursor = yield* ctx.iterate(init)
    if (cursor === undefined) {
-      throw typeError("new Map(...) expects an iterable of [key, value] pairs or no argument.")
+      throw typeError(`new Map(...) expects an iterable of [key, value] pairs, received ${describeValue(init)}.`)
    }
    while (true) {
      const step = yield* cursor.next
      if (step.done) return target
      yield* preserveConsumerError(
-        cursor,
+        cursor.close,
        Effect.sync(() => {
          if (!(step.value instanceof Obj)) {
            throw typeError("new Map(...) expects [key, value] pairs as entry objects.")
@@ -105,13 +107,13 @@ const constructMap = <R>(ctx: Interpreter<R>, init: unknown, proto: Obj) => {
  })
 }

-const constructSet = <R>(ctx: Interpreter<R>, init: unknown, proto: Obj) => {
+const constructSet = <R>(ctx: Interpreter<R>, init: Value, proto: Obj) => {
  const target = new SetObj(proto)
  if (init === undefined || init === null) return Effect.succeed(target)
  return Effect.gen(function* () {
    const cursor = yield* ctx.iterate(init)
    if (cursor === undefined) {
-      throw typeError("new Set(...) expects a synchronous iterable or no argument.")
+      throw typeError(`new Set(...) expects a synchronous iterable, received ${describeValue(init)}.`)
    }
    while (true) {
      const step = yield* cursor.next
@@ -130,8 +132,7 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {
    construct: (args, newTarget) => constructMap(ctx, args[0], prototypeFrom(newTarget, proto)),
  })
  define(map, "groupBy", groupBy(ctx, "Map"), hidden)
-  const self = (thisValue: unknown, name: string) => receiver(MapObj, thisValue, `Map.prototype.${name}`)
-  const wrap = (items: Array<unknown>) => new Arr(builtins.Array, items)
+  const self = (thisValue: Value, name: string) => receiver(MapObj, thisValue, `Map.prototype.${name}`)
  defineAccessor(proto, "size", (thisValue) => receiver(MapObj, thisValue, "Map.prototype.size").map.size)
  methods(builtins, proto, [
    ["get", 1, (thisValue, args) => self(thisValue, "get").map.get(args[0])],
@@ -145,6 +146,29 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {
        return target
      },
    ],
+    [
+      "getOrInsert",
+      2,
+      (thisValue, args) => {
+        const target = self(thisValue, "getOrInsert").map
+        if (!target.has(args[0])) target.set(args[0], args[1])
+        return target.get(args[0])
+      },
+    ],
+    [
+      "getOrInsertComputed",
+      2,
+      (thisValue, args) => {
+        const target = self(thisValue, "getOrInsertComputed").map
+        const apply = applyCollectionCallback(ctx, args[1], "Map.getOrInsertComputed")
+        if (target.has(args[0])) return target.get(args[0])
+        // The callback sees the stored key (-0 is +0) and its result wins over anything it inserted itself.
+        return Effect.map(apply([args[0] === 0 ? 0 : args[0]]), (value) => {
+          target.set(args[0], value)
+          return value
+        })
+      },
+    ],
    ["delete", 1, (thisValue, args) => self(thisValue, "delete").map.delete(args[0])],
    [
      "clear",
@@ -154,19 +178,9 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {
        return undefined
      },
    ],
-    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").map.keys())],
-    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").map.values())],
-    [
-      "entries",
-      0,
-      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
-          self(thisValue, "entries")
-            .map.entries()
-            .map(([key, item]) => wrap([key, item])),
-        ),
-    ],
+    ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").map.keys())],
+    ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").map.values())],
+    ["entries", 0, (thisValue) => hostIterator(builtins, self(thisValue, "entries").iterator(builtins))],
    [
      "forEach",
      1,
@@ -186,26 +200,26 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {

 type SetRecord<R> = {
  readonly size: number
-  readonly has: (item: unknown) => Effect.Effect<boolean, unknown, R>
-  readonly keys: () => Effect.Effect<Iterable<unknown>, unknown, R>
+  readonly has: (item: Value) => Effect.Effect<boolean, unknown, R>
+  readonly keys: () => Effect.Effect<Iterable<Value>, unknown, R>
 }

 const loadSetRecord = <R>(
  ctx: Interpreter<R>,
-  source: unknown,
+  source: Value,
  name: string,
 ): Effect.Effect<SetRecord<R>, unknown, R> => {
  if (source instanceof SetObj) {
    return Effect.succeed({
      size: source.set.size,
-      has: (item: unknown) => Effect.succeed(source.set.has(item)),
+      has: (item: Value) => Effect.succeed(source.set.has(item)),
      keys: () => Effect.succeed(source.set.values()),
    })
  }
  if (source instanceof MapObj) {
    return Effect.succeed({
      size: source.map.size,
-      has: (item: unknown) => Effect.succeed(source.map.has(item)),
+      has: (item: Value) => Effect.succeed(source.map.has(item)),
      keys: () => Effect.succeed(source.map.keys()),
    })
  }
@@ -224,12 +238,17 @@ const loadSetRecord = <R>(
    }
    return {
      size: Math.max(Math.trunc(size), 0),
-      has: (item: unknown) => Effect.map(ctx.call(has, source, [item]), Boolean),
+      has: (item: Value) => Effect.map(ctx.call(has, source, [item]), Boolean),
      keys: () =>
-        Effect.flatMap(ctx.call(keys, source, []), (result): Effect.Effect<Iterable<unknown>> => {
-          if (result instanceof IteratorObj) return Effect.succeed(result.iterator)
-          if (result instanceof Arr) return Effect.succeed(result.items)
-          throw typeError(`Set.${name} expected 'keys' to return an iterator.`)
+        Effect.gen(function* () {
+          const result = yield* ctx.call(keys, source, [])
+          const cursor = result instanceof Arr ? hostCursor(result.items.values()) : ctx.iterateDirect(result)
+          const items: Array<Value> = []
+          while (true) {
+            const step = yield* cursor.next
+            if (step.done) return items
+            items.push(step.value)
+          }
        }),
    }
  })
@@ -239,8 +258,8 @@ const setOperation = <R>(
  ctx: Interpreter<R>,
  target: SetObj,
  name: string,
-  source: unknown,
-): Effect.Effect<unknown, unknown, R> =>
+  source: Value,
+): Effect.Effect<Value, unknown, R> =>
  Effect.gen(function* () {
    const other = yield* loadSetRecord(ctx, source, name)
    const copy = () => {
@@ -319,8 +338,8 @@ export const setGlobal = <R>(ctx: Interpreter<R>) => {
    call: requiresNew("Set"),
    construct: (args, newTarget) => constructSet(ctx, args[0], prototypeFrom(newTarget, proto)),
  })
-  const self = (thisValue: unknown, name: string) => receiver(SetObj, thisValue, `Set.prototype.${name}`)
-  const wrap = (items: Array<unknown>) => new Arr(builtins.Array, items)
+  const self = (thisValue: Value, name: string) => receiver(SetObj, thisValue, `Set.prototype.${name}`)
+  const wrap = (items: Array<Value>) => new Arr(builtins.Array, items)
  const operation = (name: string): Method => [
    name,
    1,
@@ -347,14 +366,14 @@ export const setGlobal = <R>(ctx: Interpreter<R>) => {
        return undefined
      },
    ],
-    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").set.values())],
-    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").set.values())],
+    ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").set.values())],
+    ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").set.values())],
    [
      "entries",
      0,
      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
+        hostIterator(
+          builtins,
          self(thisValue, "entries")
            .set.values()
            .map((item) => wrap([item, item])),
@@ -1,22 +1,8 @@
 import { type Method, methods } from "../interpreter/native.js"
-import {
-  entries,
-  get,
-  Arr,
-  Bytes,
-  DateObj,
-  MapObj,
-  Obj,
-  PromiseObj,
-  RegExpObj,
-  SetObj,
-  URLObj,
-  URLSearchParamsObj,
-  HeadersObj,
-} from "../interpreter/objects.js"
-import { containsOpaqueReference, isRuntimeReference } from "../interpreter/references.js"
+import { entries, get, Arr, Obj, type Value } from "../interpreter/objects.js"
+import { ToolReference } from "../tool-runtime.js"
+import { containsOpaqueReference } from "../interpreter/references.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
-import { coerceToString } from "./value.js"

 const consoleMethods = ["log", "info", "debug", "warn", "error", "dir", "table"]

@@ -43,7 +29,7 @@ export const consoleGlobal = <R>(ctx: Interpreter<R>) => {

 const MAX_CONSOLE_DEPTH = 32

-const formatConsoleMessage = (name: string, args: Array<unknown>): string => {
+const formatConsoleMessage = (name: string, args: Array<Value>): string => {
  if (name === "dir") return args.length === 0 ? "undefined" : formatValue(args[0])
  if (name === "table") return formatConsoleTable(args[0], args[1])
  const prefix = name === "warn" ? "[warn] " : name === "error" ? "[error] " : name === "debug" ? "[debug] " : ""
@@ -51,60 +37,27 @@ const formatConsoleMessage = (name: string, args: Array<unknown>): string => {
 }

 /** One value as `console.log` shows it. */
-export const formatValue = (value: unknown): string => {
+export const formatValue = (value: Value): string => {
  if (value === undefined) return "undefined"
  if (typeof value === "string") return value
  return formatConsoleValue(value, new Set(), 0)
 }

-const formatConsoleValue = (value: unknown, seen: Set<object>, depth: number): string => {
+const formatConsoleValue = (value: Value, seen: Set<object>, depth: number): string => {
  if (value === null || value === undefined) return "null"
  if (typeof value === "string") return JSON.stringify(value)
-  if (typeof value === "number" || typeof value === "boolean") return String(value)
-  if (typeof value !== "object") return String(value)
-  if (value instanceof PromiseObj) return "[Promise (await it to get its value)]"
-  if (value instanceof DateObj) return coerceToString(value)
-  if (value instanceof RegExpObj) return coerceToString(value)
-  if (value instanceof URLObj) return coerceToString(value)
-  if (value instanceof URLSearchParamsObj) return coerceToString(value)
-  if (value instanceof HeadersObj) return `Headers ${JSON.stringify(Object.fromEntries(value.headers))}`
-  if (value instanceof Bytes) return `Uint8Array(${value.bytes.length}) [${value.bytes.join(",")}]`
+  if (!(value instanceof Obj)) return value instanceof ToolReference ? "[opaque reference]" : String(value)
  if (depth > MAX_CONSOLE_DEPTH) return "..."
  if (seen.has(value)) return "[Circular]"
-  if (value instanceof MapObj) {
-    seen.add(value)
-    try {
-      const items = Array.from(value.map.entries(), ([key, item]) => `[${formatItems([key, item], seen, depth + 1)}]`)
-      return `Map(${value.map.size}) [${items.join(",")}]`
-    } finally {
-      seen.delete(value)
-    }
-  }
-  if (value instanceof SetObj) {
-    seen.add(value)
-    try {
-      return `Set(${value.set.size}) [${formatItems([...value.set.values()], seen, depth + 1)}]`
-    } finally {
-      seen.delete(value)
-    }
-  }
-  if (isRuntimeReference(value)) return "[opaque reference]"
  seen.add(value)
  try {
-    if (value instanceof Arr) return `[${formatItems(value.items, seen, depth + 1)}]`
-    if (!(value instanceof Obj)) return "[object Object]"
-    return `{${entries(value)
-      .map(([key, item]) => `${JSON.stringify(key)}:${formatConsoleValue(item, seen, depth + 1)}`)
-      .join(",")}}`
+    return value.inspect((item) => formatConsoleValue(item, seen, depth + 1))
  } finally {
    seen.delete(value)
  }
 }

-const formatItems = (items: Array<unknown>, seen: Set<object>, depth: number): string =>
-  items.map((item) => formatConsoleValue(item, seen, depth)).join(",")
-
-const formatConsoleTable = (value: unknown, columnsArgument: unknown): string => {
+const formatConsoleTable = (value: Value, columnsArgument: Value): string => {
  if (value === undefined) return "undefined"
  if (containsOpaqueReference(value)) return "[opaque reference]"
  const columns = columnsArgument instanceof Arr ? columnsArgument.items.map(String) : undefined
@@ -118,9 +71,9 @@ const formatConsoleTable = (value: unknown, columnsArgument: unknown): string =>
 }

 const consoleTableRows = (
-  data: unknown,
+  data: Value,
  columns: ReadonlyArray<string> | undefined,
-): Array<{ readonly index: string; readonly values: Record<string, unknown> }> => {
+): Array<{ readonly index: string; readonly values: Record<string, Value> }> => {
  if (data instanceof Arr) {
    return data.items.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }))
  }
@@ -130,7 +83,7 @@ const consoleTableRows = (
  return [{ index: "0", values: { Value: data } }]
 }

-const consoleTableValues = (value: unknown, columns: ReadonlyArray<string> | undefined): Record<string, unknown> => {
+const consoleTableValues = (value: Value, columns: ReadonlyArray<string> | undefined): Record<string, Value> => {
  if (value instanceof Obj && !(value instanceof Arr)) {
    if (columns !== undefined) return Object.fromEntries(columns.map((column) => [column, get(value, column)]))
    return Object.fromEntries(entries(value))
@@ -138,7 +91,7 @@ const consoleTableValues = (value: unknown, columns: ReadonlyArray<string> | und
  return { Value: value }
 }

-const formatConsoleTableCell = (value: unknown): string => {
+const formatConsoleTableCell = (value: Value): string => {
  if (value === undefined) return ""
  if (typeof value === "string") return value
  return formatConsoleValue(value, new Set(), 0)
@@ -1,12 +1,11 @@
 import { Effect } from "effect"
 import { constructor, type Method, methods, prototypeFrom, receiver } from "../interpreter/native.js"
 import { rangeError } from "../interpreter/model.js"
-import { DateObj, Obj } from "../interpreter/objects.js"
+import { DateObj, Obj, coerceToNumber, coerceToString, type Value } from "../interpreter/objects.js"
 import { toPrimitive, toPrimitiveNumber } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
-import { coerceToNumber, coerceToString } from "./value.js"

-const constructDate = <R>(ctx: Interpreter<R>, args: Array<unknown>, proto: Obj) => {
+const constructDate = <R>(ctx: Interpreter<R>, args: Array<Value>, proto: Obj) => {
  if (args.length === 0) return Effect.succeed(new DateObj(proto, Date.now()))
  if (args.length === 1) {
    const arg = args[0]
@@ -83,7 +82,7 @@ export const dateGlobal = <R>(ctx: Interpreter<R>) => {
    ["UTC", 7, (_, args) => Date.UTC(...(args.map((arg) => coerceToNumber(arg)) as Parameters<typeof Date.UTC>))],
  ])

-  const self = (thisValue: unknown, name: string) => receiver(DateObj, thisValue, `Date.prototype.${name}`)
+  const self = (thisValue: Value, name: string) => receiver(DateObj, thisValue, `Date.prototype.${name}`)
  const iso = (value: DateObj) => {
    if (!Number.isFinite(value.time)) throw rangeError("Invalid time value.")
    return new Date(value.time).toISOString()
@@ -105,6 +104,13 @@ export const dateGlobal = <R>(ctx: Interpreter<R>) => {
    ["toTimeString", 0, (thisValue) => new Date(self(thisValue, "toTimeString").time).toTimeString()],
    ["toUTCString", 0, (thisValue) => new Date(self(thisValue, "toUTCString").time).toUTCString()],
    ["toGMTString", 0, (thisValue) => new Date(self(thisValue, "toGMTString").time).toUTCString()],
+    ...(["toLocaleString", "toLocaleDateString", "toLocaleTimeString"] as const).map(
+      (name): Method => [
+        name,
+        0,
+        (thisValue) => new Date(self(thisValue, name).time)[name]("en-US", { timeZone: "UTC" }),
+      ],
+    ),
    ...getters.map((name): Method => [name, 0, (thisValue) => new Date(self(thisValue, name).time)[name]()]),
    ...setters.map(
      ([name, length]): Method => [
@@ -1,11 +1,21 @@
 import { Effect } from "effect"
 import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js"
 import { IteratorSymbol, typeError } from "../interpreter/model.js"
-import { define, entries, get, hidden, Arr, HeadersObj, IteratorObj, Obj } from "../interpreter/objects.js"
+import {
+  define,
+  entries,
+  get,
+  hidden,
+  Arr,
+  HeadersObj,
+  hostIterator,
+  Obj,
+  coerceToString,
+  isRuntimeReference,
+  type Value,
+} from "../interpreter/objects.js"
 import { applyCollectionCallback } from "../interpreter/callback.js"
-import { isRuntimeReference } from "../interpreter/references.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
-import { coerceToString } from "./value.js"
 import { readPairs } from "./url.js"

 // The host validates header names and values and throws its own TypeError; the program gets one of its own.
@@ -17,7 +27,7 @@ const attempt = <T>(run: () => T): T => {
  }
 }

-const constructHeaders = <R>(ctx: Interpreter<R>, init: unknown, proto: Obj): Effect.Effect<HeadersObj, unknown, R> => {
+const constructHeaders = <R>(ctx: Interpreter<R>, init: Value, proto: Obj): Effect.Effect<HeadersObj, unknown, R> => {
  const wrap = (headers: Headers) => new HeadersObj(proto, headers)
  if (init === undefined) return Effect.succeed(wrap(new Headers()))
  return Effect.gen(function* () {
@@ -40,10 +50,10 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
    call: requiresNew("Headers"),
    construct: (args, newTarget) => constructHeaders(ctx, args[0], prototypeFrom(newTarget, proto)),
  })
-  const self = (thisValue: unknown, name: string) => receiver(HeadersObj, thisValue, `Headers.prototype.${name}`)
-  const wrap = (items: Array<unknown>) => new Arr(builtins.Array, items)
-  const arg = (args: Array<unknown>, index: number): string => coerceToString(args[index])
-  const requireArgs = (name: string, args: Array<unknown>, count: number): void => {
+  const self = (thisValue: Value, name: string) => receiver(HeadersObj, thisValue, `Headers.prototype.${name}`)
+  const wrap = (items: Array<Value>) => new Arr(builtins.Array, items)
+  const arg = (args: Array<Value>, index: number): string => coerceToString(args[index])
+  const requireArgs = (name: string, args: Array<Value>, count: number): void => {
    if (args.length < count) throw typeError(`Headers.${name} requires ${count} argument${count === 1 ? "" : "s"}.`)
  }
  methods(builtins, proto, [
@@ -53,7 +63,8 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
      (thisValue, args) => {
        requireArgs("append", args, 2)
        const target = self(thisValue, "append").headers
-        return attempt(() => target.append(arg(args, 0), arg(args, 1)))
+        attempt(() => target.append(arg(args, 0), arg(args, 1)))
+        return undefined
      },
    ],
    [
@@ -62,7 +73,8 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
      (thisValue, args) => {
        requireArgs("delete", args, 1)
        const target = self(thisValue, "delete").headers
-        return attempt(() => target.delete(arg(args, 0)))
+        attempt(() => target.delete(arg(args, 0)))
+        return undefined
      },
    ],
    [
@@ -90,29 +102,13 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
      (thisValue, args) => {
        requireArgs("set", args, 2)
        const target = self(thisValue, "set").headers
-        return attempt(() => target.set(arg(args, 0), arg(args, 1)))
+        attempt(() => target.set(arg(args, 0), arg(args, 1)))
+        return undefined
      },
    ],
-    // Iterator.from because Bun's Headers typings predate iterator helpers; the runtime iterators already have them.
-    [
-      "keys",
-      0,
-      (thisValue) => new IteratorObj(builtins.Iterator, Iterator.from(self(thisValue, "keys").headers.keys())),
-    ],
-    [
-      "values",
-      0,
-      (thisValue) => new IteratorObj(builtins.Iterator, Iterator.from(self(thisValue, "values").headers.values())),
-    ],
-    [
-      "entries",
-      0,
-      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
-          Iterator.from(self(thisValue, "entries").headers.entries()).map(([key, value]) => wrap([key, value])),
-        ),
-    ],
+    ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").headers.keys())],
+    ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").headers.values())],
+    ["entries", 0, (thisValue) => hostIterator(builtins, self(thisValue, "entries").iterator(builtins))],
    [
      "forEach",
      1,
@@ -1,19 +1,348 @@
-import { methods, receiver } from "../interpreter/native.js"
-import { IteratorObj, record } from "../interpreter/objects.js"
+import { Cause, Effect, Exit } from "effect"
+import { applyCollectionCallback } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
+import { rangeError, typeError } from "../interpreter/model.js"
+import { constructor, fn, methods, receiver, requiresNew } from "../interpreter/native.js"
+import {
+  Arr,
+  coerceToNumber,
+  type Cursor,
+  define,
+  hasPrototype,
+  hidden,
+  IteratorObj,
+  Obj,
+  record,
+  type Step,
+  type Value,
+} from "../interpreter/objects.js"
+import { describeValue } from "../interpreter/references.js"

-// Every built-in collection iterator shares the Iterator prototype; JS gives each collection its own, which is only
+const finished: Step = { done: true, value: undefined }
+
+// Every built-in iterator and helper shares the Iterator prototype; JS gives each collection its own, which is only
 // observable through getPrototypeOf.
-export const iteratorGlobals = <R>(ctx: Interpreter<R>): void => {
+export const iteratorGlobals = <R>(ctx: Interpreter<R>) => {
  const builtins = ctx.builtins
-  methods(builtins, builtins.Iterator, [
+  const proto = builtins.Iterator
+  const method = (name: string) => `Iterator.prototype.${name}`
+
+  // A step that runs program code: when it throws, close the source first, as IteratorClose does.
+  const guarded = <A>(source: Cursor<R>, body: Effect.Effect<A, unknown, R>) =>
+    Effect.flatMap(Effect.exit(body), (exit) => {
+      if (Exit.isSuccess(exit)) return Effect.succeed(exit.value)
+      if (Cause.hasInterruptsOnly(exit.cause)) return Effect.failCause(exit.cause)
+      return Effect.andThen(Effect.exit(source.close), Effect.failCause(exit.cause))
+    })
+
+  // A lazy helper: `pull` advances it once. Once it reports done, throws, or is closed, it stays done. A callback
+  // that re-enters its own helper is a TypeError, as for a running generator.
+  const helper = (source: Cursor<R>, pull: Effect.Effect<Step, unknown, R>, close = source.close) => {
+    let done = false
+    let running = false
+    const enter = () => {
+      if (running) throw typeError("Iterator helper is already running.")
+      running = true
+    }
+    return new IteratorObj(builtins.IteratorHelper, {
+      next: Effect.suspend(() => {
+        if (done) return Effect.succeed(finished)
+        enter()
+        return Effect.flatMap(Effect.exit(pull), (exit) => {
+          running = false
+          done = Exit.isSuccess(exit) ? exit.value.done : true
+          return exit
+        })
+      }),
+      close: Effect.suspend(() => {
+        if (done) return Effect.void
+        enter()
+        done = true
+        return Effect.ensuring(
+          close,
+          Effect.sync(() => {
+            running = false
+          }),
+        )
+      }),
+    })
+  }
+
+  // GetIteratorFlattenable: an iterable by `[Symbol.iterator]`, otherwise the object itself as an iterator.
+  const flattenable = (value: Value, name: string, strings: boolean) =>
+    Effect.gen(function* () {
+      if (typeof value === "string" ? !strings : !(value instanceof Obj)) {
+        throw typeError(`${name} expects an iterable or iterator, received ${describeValue(value)}.`)
+      }
+      return (yield* ctx.iterate(value)) ?? ctx.iterateDirect(value)
+    })
+
+  const limit = (value: Value, name: string) => {
+    const count = Math.trunc(coerceToNumber(value))
+    if (Number.isNaN(count) || count < 0) {
+      throw rangeError(`${method(name)} expects a non-negative count, received ${count}.`)
+    }
+    return count
+  }
+
+  methods(builtins, proto, [
    [
      "next",
      0,
+      (thisValue) =>
+        Effect.map(receiver(IteratorObj, thisValue, method("next")).cursor.next, (step) =>
+          record(builtins.Object, { value: step.value, done: step.done }),
+        ),
+    ],
+    [
+      "map",
+      1,
+      (thisValue, args) => {
+        const source = ctx.iterateDirect(thisValue)
+        const apply = applyCollectionCallback(ctx, args[0], method("map"))
+        let counter = 0
+        return helper(
+          source,
+          Effect.gen(function* () {
+            const step = yield* source.next
+            if (step.done) return finished
+            return { done: false, value: yield* guarded(source, apply([step.value, counter++])) }
+          }),
+        )
+      },
+    ],
+    [
+      "filter",
+      1,
+      (thisValue, args) => {
+        const source = ctx.iterateDirect(thisValue)
+        const apply = applyCollectionCallback(ctx, args[0], method("filter"))
+        let counter = 0
+        return helper(
+          source,
+          Effect.gen(function* () {
+            while (true) {
+              const step = yield* source.next
+              if (step.done) return finished
+              if (yield* guarded(source, apply([step.value, counter++]))) return step
+            }
+          }),
+        )
+      },
+    ],
+    [
+      "take",
+      1,
+      (thisValue, args) => {
+        const source = ctx.iterateDirect(thisValue)
+        let remaining = limit(args[0], "take")
+        return helper(
+          source,
+          Effect.gen(function* () {
+            if (remaining === 0) {
+              yield* source.close
+              return finished
+            }
+            remaining -= 1
+            return yield* source.next
+          }),
+        )
+      },
+    ],
+    [
+      "drop",
+      1,
+      (thisValue, args) => {
+        const source = ctx.iterateDirect(thisValue)
+        let remaining = limit(args[0], "drop")
+        return helper(
+          source,
+          Effect.gen(function* () {
+            while (remaining > 0) {
+              remaining -= 1
+              const step = yield* source.next
+              if (step.done) return finished
+            }
+            return yield* source.next
+          }),
+        )
+      },
+    ],
+    [
+      "flatMap",
+      1,
+      (thisValue, args) => {
+        const source = ctx.iterateDirect(thisValue)
+        const apply = applyCollectionCallback(ctx, args[0], method("flatMap"))
+        let counter = 0
+        let inner: Cursor<R> | undefined
+        return helper(
+          source,
+          Effect.gen(function* () {
+            while (true) {
+              if (inner !== undefined) {
+                const step = yield* guarded(source, inner.next)
+                if (!step.done) return step
+                inner = undefined
+              }
+              const step = yield* source.next
+              if (step.done) return finished
+              inner = yield* guarded(
+                source,
+                Effect.flatMap(apply([step.value, counter++]), (mapped) =>
+                  flattenable(mapped, method("flatMap"), false),
+                ),
+              )
+            }
+          }),
+          Effect.suspend(() => (inner === undefined ? source.close : Effect.andThen(inner.close, source.close))),
+        )
+      },
+    ],
+    [
+      "reduce",
+      1,
+      (thisValue, args) => {
+        const source = ctx.iterateDirect(thisValue)
+        const apply = applyCollectionCallback(ctx, args[0], method("reduce"))
+        return Effect.gen(function* () {
+          let counter = 0
+          let accumulator = args[1]
+          if (args.length < 2) {
+            const first = yield* source.next
+            if (first.done) throw typeError("Iterator.prototype.reduce of an empty iterator with no initial value.")
+            accumulator = first.value
+            counter = 1
+          }
+          while (true) {
+            const step = yield* source.next
+            if (step.done) return accumulator
+            accumulator = yield* guarded(source, apply([accumulator, step.value, counter++]))
+          }
+        })
+      },
+    ],
+    [
+      "toArray",
+      0,
      (thisValue) => {
-        const step = receiver(IteratorObj, thisValue, "Iterator.prototype.next").iterator.next()
-        return record(builtins.Object, { value: step.value, done: Boolean(step.done) })
+        const source = ctx.iterateDirect(thisValue)
+        return Effect.gen(function* () {
+          const items: Array<Value> = []
+          while (true) {
+            const step = yield* source.next
+            if (step.done) return new Arr(builtins.Array, items)
+            items.push(step.value)
+          }
+        })
+      },
+    ],
+    [
+      "forEach",
+      1,
+      (thisValue, args) => {
+        const source = ctx.iterateDirect(thisValue)
+        const apply = applyCollectionCallback(ctx, args[0], method("forEach"))
+        return Effect.gen(function* () {
+          let counter = 0
+          while (true) {
+            const step = yield* source.next
+            if (step.done) return undefined
+            yield* guarded(source, apply([step.value, counter++]))
+          }
+        })
+      },
+    ],
+    [
+      "some",
+      1,
+      (thisValue, args) => {
+        const source = ctx.iterateDirect(thisValue)
+        const apply = applyCollectionCallback(ctx, args[0], method("some"))
+        return Effect.gen(function* () {
+          let counter = 0
+          while (true) {
+            const step = yield* source.next
+            if (step.done) return false
+            if (yield* guarded(source, apply([step.value, counter++]))) {
+              yield* source.close
+              return true
+            }
+          }
+        })
+      },
+    ],
+    [
+      "every",
+      1,
+      (thisValue, args) => {
+        const source = ctx.iterateDirect(thisValue)
+        const apply = applyCollectionCallback(ctx, args[0], method("every"))
+        return Effect.gen(function* () {
+          let counter = 0
+          while (true) {
+            const step = yield* source.next
+            if (step.done) return true
+            if (!(yield* guarded(source, apply([step.value, counter++])))) {
+              yield* source.close
+              return false
+            }
+          }
+        })
+      },
+    ],
+    [
+      "find",
+      1,
+      (thisValue, args) => {
+        const source = ctx.iterateDirect(thisValue)
+        const apply = applyCollectionCallback(ctx, args[0], method("find"))
+        return Effect.gen(function* () {
+          let counter = 0
+          while (true) {
+            const step = yield* source.next
+            if (step.done) return undefined
+            if (yield* guarded(source, apply([step.value, counter++]))) {
+              yield* source.close
+              return step.value
+            }
+          }
+        })
      },
    ],
  ])
+
+  // Helpers and `Iterator.from` wrappers can be closed; collection iterators, as in JS, cannot.
+  methods(builtins, builtins.IteratorHelper, [
+    [
+      "return",
+      0,
+      (thisValue) =>
+        Effect.map(receiver(IteratorObj, thisValue, "Iterator.prototype.return").cursor.close, () =>
+          record(builtins.Object, { value: undefined, done: true }),
+        ),
+    ],
+  ])
+
+  const iterator = constructor<R>(builtins, proto, {
+    name: "Iterator",
+    length: 0,
+    call: requiresNew("Iterator"),
+    construct: () =>
+      Effect.sync(() => {
+        throw typeError("Iterator is abstract; use Iterator.from(...) or a built-in iterator.")
+      }),
+  })
+  define(
+    iterator,
+    "from",
+    fn(builtins, "from", 1, (_, args) =>
+      Effect.gen(function* () {
+        if (args[0] instanceof Obj && hasPrototype(args[0], proto)) return args[0]
+        return new IteratorObj(builtins.IteratorHelper, yield* flattenable(args[0], "Iterator.from", true))
+      }),
+    ),
+    hidden,
+  )
+  return iterator
 }
@@ -6,7 +6,7 @@ import { checkStringLength } from "../interpreter/limits.js"
 import { syntaxError, typeError } from "../interpreter/model.js"
 import { typeofValue } from "../interpreter/references.js"
 import { fromJson, toJson } from "../data.js"
-import { get, keys, Arr, Obj, record, remove, set } from "../interpreter/objects.js"
+import { get, keys, Arr, Obj, record, remove, set, type Value } from "../interpreter/objects.js"

 export const jsonGlobal = <R>(ctx: Interpreter<R>) => {
  const json = new Obj(ctx.builtins.Object)
@@ -17,7 +17,7 @@ export const jsonGlobal = <R>(ctx: Interpreter<R>) => {
  return json
 }

-const parse = <R>(ctx: Interpreter<R>, args: Array<unknown>): Effect.Effect<unknown, unknown, R> => {
+const parse = <R>(ctx: Interpreter<R>, args: Array<Value>): Effect.Effect<Value, unknown, R> => {
  const text = args[0]
  if (typeof text !== "string") throw typeError("JSON.parse expects a string.")

@@ -31,7 +31,7 @@ const parse = <R>(ctx: Interpreter<R>, args: Array<unknown>): Effect.Effect<unkn
  if (typeofValue(args[1]) !== "function") return Effect.succeed(parsed)

  const apply = applyCollectionCallback(ctx, args[1], "JSON.parse")
-  const visit = (holder: Obj, key: string): Effect.Effect<unknown, unknown, R> =>
+  const visit = (holder: Obj, key: string): Effect.Effect<Value, unknown, R> =>
    Effect.gen(function* () {
      const value = get(holder, key)
      if (value instanceof Obj) {
@@ -46,7 +46,7 @@ const parse = <R>(ctx: Interpreter<R>, args: Array<unknown>): Effect.Effect<unkn
  return visit(record(ctx.builtins.Object, { "": parsed }), "")
 }

-const stringify = <R>(ctx: Interpreter<R>, args: Array<unknown>): Effect.Effect<unknown, unknown, R> => {
+const stringify = <R>(ctx: Interpreter<R>, args: Array<Value>): Effect.Effect<Value, unknown, R> => {
  const space = args[2]
  const indent = typeof space === "number" || typeof space === "string" ? space : undefined
  const replacer = args[1]
@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import { constants, type Method, methods } from "../interpreter/native.js"
 import { typeError } from "../interpreter/model.js"
-import { Obj } from "../interpreter/objects.js"
+import { Obj, type Value } from "../interpreter/objects.js"
 import { preserveConsumerError } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"

@@ -14,7 +14,7 @@ declare global {

 // Validate only the arguments a method consumes; like JS, extras are ignored
 // (so built-ins work as callbacks receiving (element, index, array)).
-const number = (name: string, args: Array<unknown>, index: number): number => {
+const number = (name: string, args: Array<Value>, index: number): number => {
  if (index >= args.length) return Number.NaN
  const arg = args[index]
  if (typeof arg !== "number") throw typeError(`Math.${name} expects number arguments.`)
@@ -105,7 +105,7 @@ export const mathGlobal = <R>(ctx: Interpreter<R>) => {
            const step = yield* cursor.next
            if (step.done) return Math.sumPrecise(numbers)
            yield* preserveConsumerError(
-              cursor,
+              cursor.close,
              Effect.sync(() => {
                if (typeof step.value !== "number") {
                  throw typeError("Math.sumPrecise expects an iterable of numbers.")
@@ -1,7 +1,8 @@
 import { constructor, constants, methods } from "../interpreter/native.js"
+import { coerceToString, type Value } from "../interpreter/objects.js"
 import { rangeError, typeError } from "../interpreter/model.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
-import { coercion, coerceToString } from "./value.js"
+import { coercion } from "./value.js"

 export const numberGlobal = <R>(ctx: Interpreter<R>) => {
  const builtins = ctx.builtins
@@ -39,17 +40,18 @@ export const numberGlobal = <R>(ctx: Interpreter<R>) => {
    ["parseFloat", 1, (_, args) => parseFloat(coerceToString(args[0]))],
  ])

-  const self = (thisValue: unknown, name: string): number => {
+  const self = (thisValue: Value, name: string): number => {
    if (typeof thisValue === "number") return thisValue
    throw typeError(`Number.prototype.${name} requires that 'this' be a Number.`)
  }
-  const optNum = (name: string, arg: unknown): number | undefined => {
+  const optNum = (name: string, arg: Value): number | undefined => {
    if (arg === undefined) return undefined
    if (typeof arg !== "number") throw typeError(`Number.${name} expects a number argument.`)
    return arg
  }
  methods(builtins, builtins.Number, [
    ["toFixed", 1, (thisValue, args) => self(thisValue, "toFixed").toFixed(optNum("toFixed", args[0]))],
+    ["toLocaleString", 0, (thisValue) => self(thisValue, "toLocaleString").toLocaleString("en-US")],
    [
      "toExponential",
      1,
@@ -88,7 +90,7 @@ export const booleanGlobal = <R>(ctx: Interpreter<R>) => {
    length: 1,
    call: coercion(ctx, "Boolean").call,
  })
-  const self = (thisValue: unknown, name: string): boolean => {
+  const self = (thisValue: Value, name: string): boolean => {
    if (typeof thisValue === "boolean") return thisValue
    throw typeError(`Boolean.prototype.${name} requires that 'this' be a Boolean.`)
  }
@@ -9,7 +9,6 @@ import {
  typeError,
 } from "../interpreter/model.js"
 import {
-  Callable,
  define,
  entries,
  enumerableKeys,
@@ -20,23 +19,20 @@ import {
  keys,
  own,
  Arr,
-  Bytes,
-  DateObj,
-  ErrorObj,
  Obj,
  PromiseObj,
-  RegExpObj,
  set,
+  coerceToString,
+  type Value,
 } from "../interpreter/objects.js"
 import { containsOpaqueReference, describeValue, rejectCircularInsertion } from "../interpreter/references.js"
-import { preserveConsumerError } from "../interpreter/callback.js"
+import { invoke, preserveConsumerError } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
 import { ToolReference } from "../tool-runtime.js"
 import { groupBy } from "./collections.js"
-import { coerceToString } from "./value.js"

 // ToObject for enumeration.
-export const enumerableSource = <R>(ctx: Interpreter<R>, label: string, value: unknown, node?: AstNode): Obj => {
+export const enumerableSource = <R>(ctx: Interpreter<R>, label: string, value: Value, node?: AstNode): Obj => {
  if (value === null || value === undefined) {
    throw typeError(`${label} cannot convert ${describeValue(value)} to an object.`, node)
  }
@@ -54,7 +50,7 @@ export const enumerableSource = <R>(ctx: Interpreter<R>, label: string, value: u
  return new Obj(ctx.builtins.Object)
 }

-export const objectAssign = <R>(ctx: Interpreter<R>, args: Array<unknown>): unknown => {
+export const objectAssign = <R>(ctx: Interpreter<R>, args: Array<Value>): Value => {
  const target = args[0]
  // JS would box a primitive target; wrappers and primitives cannot hold fields here.
  if (!(target instanceof Obj)) {
@@ -75,7 +71,7 @@ export const objectAssign = <R>(ctx: Interpreter<R>, args: Array<unknown>): unkn
  return target
 }

-const objectFromEntries = <R>(ctx: Interpreter<R>, source: unknown): Effect.Effect<Obj, unknown, R> => {
+const objectFromEntries = <R>(ctx: Interpreter<R>, source: Value): Effect.Effect<Obj, unknown, R> => {
  const out = new Obj(ctx.builtins.Object)
  return Effect.gen(function* () {
    const cursor = yield* ctx.iterate(source)
@@ -86,7 +82,7 @@ const objectFromEntries = <R>(ctx: Interpreter<R>, source: unknown): Effect.Effe
      const step = yield* cursor.next
      if (step.done) return out
      yield* preserveConsumerError(
-        cursor,
+        cursor.close,
        Effect.sync(() => {
          if (!(step.value instanceof Obj) || containsOpaqueReference(step.value)) {
            throw typeError("Object.fromEntries expects [key, value] entry objects.")
@@ -98,29 +94,24 @@ const objectFromEntries = <R>(ctx: Interpreter<R>, source: unknown): Effect.Effe
  })
 }

-export const classTag = (value: unknown): string => {
+const classTag = (value: Value): string => {
  if (value === null) return "Null"
  if (value === undefined) return "Undefined"
-  if (value instanceof Arr) return "Array"
-  if (value instanceof Callable) return "Function"
-  if (value instanceof ErrorObj) return "Error"
-  if (value instanceof DateObj) return "Date"
-  if (value instanceof RegExpObj) return "RegExp"
-  if (value instanceof Bytes) return "Uint8Array"
+  if (value instanceof Obj) return value.tag
  if (typeof value === "string") return "String"
  if (typeof value === "number") return "Number"
  if (typeof value === "boolean") return "Boolean"
  return "Object"
 }

-const propertyKey = (value: unknown): PropertyKey =>
+const propertyKey = (value: Value): PropertyKey =>
  value === AsyncIteratorSymbol || value === IteratorSymbol ? value : coerceToString(value)

 // Object constructs identically with or without new, like JS. Only `keys` copies its result into the
 // program; `values`, `entries`, `assign`, and `fromEntries` hand back the program's own values.
 export const objectGlobal = <R>(ctx: Interpreter<R>) => {
  const builtins = ctx.builtins
-  const construct = (args: Array<unknown>): unknown => {
+  const construct = (args: Array<Value>): Value => {
    const first = args[0]
    if (first === null || first === undefined) return new Obj(builtins.Object)
    if (first instanceof Obj) return first
@@ -196,7 +187,7 @@ export const objectGlobal = <R>(ctx: Interpreter<R>) => {
        true,
    ],
    ["toString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
-    ["toLocaleString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
+    ["toLocaleString", 0, (thisValue) => invoke(ctx, thisValue, "toString", "Object.prototype.toLocaleString")],
    [
      "valueOf",
      0,
@@ -2,9 +2,18 @@ import { Effect } from "effect"
 import type { Builtins } from "../interpreter/intrinsics.js"
 import { constructor, type Method, methods, prototypeFrom, receiver } from "../interpreter/native.js"
 import { syntaxError, typeError } from "../interpreter/model.js"
-import { define, defineAccessor, Arr, Obj, RegExpObj, record } from "../interpreter/objects.js"
+import {
+  define,
+  defineAccessor,
+  Arr,
+  Obj,
+  RegExpObj,
+  record,
+  coerceToNumber,
+  coerceToString,
+  type Value,
+} from "../interpreter/objects.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
-import { coerceToNumber, coerceToString } from "./value.js"

 const flagProperties = [
  "hasIndices",
@@ -23,7 +32,7 @@ const regexFailureReason = (error: unknown): string =>
 const escapeRegexHint =
  'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.'

-export const toHostRegex = (arg: unknown, method: string, extraFlags = ""): RegExp => {
+export const toHostRegex = (arg: Value, method: string, extraFlags = ""): RegExp => {
  // Native parity: an undefined pattern behaves as an empty pattern.
  if (arg === undefined) return new RegExp("", extraFlags)
  if (arg instanceof RegExpObj) return arg.regex
@@ -53,7 +62,7 @@ export const matchToValue = (builtins: Builtins, match: RegExpMatchArray): Arr =
  return result
 }

-export const constructRegExp = (builtins: Builtins, args: Array<unknown>, proto: Obj = builtins.RegExp): RegExpObj => {
+export const constructRegExp = (builtins: Builtins, args: Array<Value>, proto: Obj = builtins.RegExp): RegExpObj => {
  const first = args[0]
  const pattern = first instanceof RegExpObj ? first.regex.source : first === undefined ? "" : coerceToString(first)
  const flagsArg = args[1]
@@ -96,7 +105,7 @@ export const regexpGlobal = <R>(ctx: Interpreter<R>) => {
    ],
  ])

-  const self = (thisValue: unknown, name: string) => receiver(RegExpObj, thisValue, `RegExp.prototype.${name}`)
+  const self = (thisValue: Value, name: string) => receiver(RegExpObj, thisValue, `RegExp.prototype.${name}`)
  defineAccessor(proto, "source", (thisValue) => self(thisValue, "source").regex.source)
  defineAccessor(proto, "flags", (thisValue) => self(thisValue, "flags").regex.flags)
  // The host regex holds the only lastIndex, so exec/test and the String methods share one counter.
@@ -1,16 +1,26 @@
 import { Effect } from "effect"
-import { constructor, fn, type Method, methods } from "../interpreter/native.js"
+import { constructor, fn, type Impl, type Method, methods } from "../interpreter/native.js"
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js"
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js"
-import { define, hidden, Arr, IteratorObj, PromiseObj, RegExpObj, record } from "../interpreter/objects.js"
+import {
+  define,
+  hidden,
+  Arr,
+  hostIterator,
+  RegExpObj,
+  record,
+  coerceToNumber,
+  coerceToString,
+  type Value,
+} from "../interpreter/objects.js"
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js"
 import { applyCollectionCallback, isSupportedCallback } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
 import { matchToValue, toHostRegex } from "./regexp.js"
-import { coerceToNumber, coerceToString, coercion } from "./value.js"
+import { coercion } from "./value.js"

 // console is intercepted by the interpreter before reaching here.
-const requireDataArgument = (name: string, index: number, arg: unknown): unknown => {
+const requireDataArgument = (name: string, index: number, arg: Value): Value => {
  if (containsOpaqueReference(arg)) {
    throw invalidData(`String.${name} expects argument ${index + 1} to be a data value.`)
  }
@@ -29,21 +39,23 @@ const replaceWithCallback = <R>(
  ctx: Interpreter<R>,
  value: string,
  name: "replace" | "replaceAll",
-  args: Array<unknown>,
-): Effect.Effect<unknown, unknown, R> => {
+  args: Array<Value>,
+): Effect.Effect<Value, unknown, R> => {
  const builtins = ctx.builtins
  const apply = applyCollectionCallback(ctx, args[1], `String.${name}`)
-  const matches: Array<{ readonly match: string; readonly offset: number; readonly args: Array<unknown> }> = []
-  const collect = (...callbackArgs: Array<unknown>): string => {
+  const matches: Array<{ readonly match: string; readonly offset: number; readonly args: Array<Value> }> = []
+  // The host calls back with (match, ...captures, offset, string, groups?); only groups is not already a Value.
+  const collect = (
+    ...callbackArgs: Array<string | number | undefined | Record<string, string | undefined>>
+  ): string => {
    const match = callbackArgs[0]
-    const groups = callbackArgs[callbackArgs.length - 1]
-    const hasGroups = groups !== null && typeof groups === "object"
+    const hasGroups = typeof callbackArgs.at(-1) === "object"
    const offset = callbackArgs[callbackArgs.length - (hasGroups ? 3 : 2)]
    if (typeof match !== "string" || typeof offset !== "number") {
      throw typeError(`String.${name} produced an invalid replacement match.`)
    }
-    if (hasGroups) callbackArgs[callbackArgs.length - 1] = record(builtins.Object, groups as Record<string, unknown>)
-    matches.push({ match, offset, args: callbackArgs })
+    const args = callbackArgs.map((arg) => (typeof arg === "object" ? record(builtins.Object, arg) : arg))
+    matches.push({ match, offset, args })
    return match
  }

@@ -63,10 +75,7 @@ const replaceWithCallback = <R>(
    let end = 0
    for (const match of matches) {
      const replacement = yield* apply(match.args)
-      output.push(
-        value.slice(end, match.offset),
-        replacement instanceof PromiseObj ? "[object Promise]" : coerceToString(replacement),
-      )
+      output.push(value.slice(end, match.offset), coerceToString(replacement))
      end = match.offset + match.match.length
    }
    output.push(value.slice(end))
@@ -99,7 +108,7 @@ export const stringGlobal = <R>(ctx: Interpreter<R>) => {
    codeUnits("fromCodePoint", String.fromCodePoint),
  ])

-  const self = (thisValue: unknown, name: string): string => {
+  const self = (thisValue: Value, name: string): string => {
    if (typeof thisValue === "string") return thisValue
    if (thisValue === null || thisValue === undefined) {
      throw typeError(`String.prototype.${name} called on null or undefined.`)
@@ -107,26 +116,26 @@ export const stringGlobal = <R>(ctx: Interpreter<R>) => {
    return coerceToString(thisValue)
  }
  // Coerce arguments like native JS; opaque runtime references still reject.
-  const str = (name: string, args: Array<unknown>, index: number): string =>
+  const str = (name: string, args: Array<Value>, index: number): string =>
    coerceToString(requireDataArgument(name, index, args[index]))
-  const num = (name: string, args: Array<unknown>, index: number): number =>
+  const num = (name: string, args: Array<Value>, index: number): number =>
    coerceToNumber(requireDataArgument(name, index, args[index]))
-  const optNum = (name: string, args: Array<unknown>, index: number): number | undefined =>
+  const optNum = (name: string, args: Array<Value>, index: number): number | undefined =>
    args[index] === undefined ? undefined : num(name, args, index)
-  const optStr = (name: string, args: Array<unknown>, index: number): string | undefined =>
+  const optStr = (name: string, args: Array<Value>, index: number): string | undefined =>
    args[index] === undefined ? undefined : str(name, args, index)
-  const rejectRegex = (name: string, args: Array<unknown>): void => {
+  const rejectRegex = (name: string, args: Array<Value>): void => {
    if (args[0] instanceof RegExpObj) {
      throw typeError(
        `String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`,
      )
    }
  }
-  const simple = (name: string, length: number, op: (value: string, args: Array<unknown>) => unknown): Method => [
-    name,
-    length,
-    (thisValue, args) => op(self(thisValue, name), args),
-  ]
+  const simple = (
+    name: string,
+    length: number,
+    op: (value: string, args: Array<Value>) => ReturnType<Impl>,
+  ): Method => [name, length, (thisValue, args) => op(self(thisValue, name), args)]
  const replace = (name: "replace" | "replaceAll") =>
    simple(name, 2, (value, args) => {
      if (isSupportedCallback(args[1])) return replaceWithCallback(ctx, value, name, args)
@@ -150,6 +159,8 @@ export const stringGlobal = <R>(ctx: Interpreter<R>) => {
    simple("valueOf", 0, (value) => value),
    simple("toLowerCase", 0, (value) => value.toLowerCase()),
    simple("toUpperCase", 0, (value) => value.toUpperCase()),
+    simple("toLocaleLowerCase", 0, (value) => value.toLowerCase()),
+    simple("toLocaleUpperCase", 0, (value) => value.toUpperCase()),
    simple("trim", 0, (value) => value.trim()),
    simple("trimStart", 0, (value) => value.trimStart()),
    simple("trimLeft", 0, (value) => value.trimStart()),
@@ -216,7 +227,7 @@ export const stringGlobal = <R>(ctx: Interpreter<R>) => {
          `String.matchAll requires a regular expression with the global (g) flag: write /${pattern.source}/${pattern.flags}g, or use String.match for a single match.`,
        )
      }
-      const matches: Array<unknown> = []
+      const matches: Array<Value> = []
      for (const match of value.matchAll(pattern)) {
        checkArrayLength(matches.length + 1)
        matches.push(matchToValue(builtins, match))
@@ -261,11 +272,8 @@ export const stringGlobal = <R>(ctx: Interpreter<R>) => {
  define(
    builtins.String,
    IteratorSymbol,
-    fn(
-      builtins,
-      "[Symbol.iterator]",
-      0,
-      (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "[Symbol.iterator]")[Symbol.iterator]()),
+    fn(builtins, "[Symbol.iterator]", 0, (thisValue) =>
+      hostIterator(builtins, self(thisValue, "[Symbol.iterator]")[Symbol.iterator]()),
    ),
    hidden,
  )
@@ -7,17 +7,17 @@ import {
  entries,
  get,
  hidden,
-  isWrapper,
  Arr,
-  IteratorObj,
+  hostIterator,
  Obj,
  URLObj,
  URLSearchParamsObj,
+  coerceToString,
+  isRuntimeReference,
+  type Value,
 } from "../interpreter/objects.js"
-import { isRuntimeReference } from "../interpreter/references.js"
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
-import { coerceToString } from "./value.js"

 const urlProperties = [
  "href",
@@ -52,12 +52,12 @@ export const uriGlobal = <R>(ctx: Interpreter<R>, name: UriFunction) =>
    }
  })

-const urlArgument = (value: unknown): string => (value instanceof URLObj ? value.url.href : coerceToString(value))
+const urlArgument = (value: Value): string => (value instanceof URLObj ? value.url.href : coerceToString(value))

 export const urlGlobal = <R>(ctx: Interpreter<R>) => {
  const builtins = ctx.builtins
  const proto = builtins.URL
-  const construct = (args: Array<unknown>, into: Obj): URLObj => {
+  const construct = (args: Array<Value>, into: Obj): URLObj => {
    if (args.length === 0) {
      throw typeError("new URL(...) requires a URL string and an optional base URL.")
    }
@@ -92,7 +92,7 @@ export const urlGlobal = <R>(ctx: Interpreter<R>) => {
  ]
  methods(builtins, url, [parse("canParse"), parse("parse")])

-  const self = (thisValue: unknown, name: string) => receiver(URLObj, thisValue, `URL.prototype.${name}`)
+  const self = (thisValue: Value, name: string) => receiver(URLObj, thisValue, `URL.prototype.${name}`)
  for (const name of urlProperties) {
    defineAccessor(
      proto,
@@ -119,7 +119,7 @@ export const urlGlobal = <R>(ctx: Interpreter<R>) => {
  return url
 }

-const readPair = <R>(ctx: Interpreter<R>, value: unknown, label: string): Effect.Effect<Array<string>, unknown, R> =>
+const readPair = <R>(ctx: Interpreter<R>, value: Value, label: string): Effect.Effect<Array<string>, unknown, R> =>
  Effect.gen(function* () {
    const cursor = yield* ctx.iterate(value)
    if (cursor === undefined) throw typeError(`${label} expects iterable [name, value] pairs.`)
@@ -129,7 +129,7 @@ const readPair = <R>(ctx: Interpreter<R>, value: unknown, label: string): Effect
      if (step.done) return items
      items.push(
        yield* preserveConsumerError(
-          cursor,
+          cursor.close,
          Effect.sync(() => coerceToString(step.value)),
        ),
      )
@@ -142,7 +142,7 @@ const readPair = <R>(ctx: Interpreter<R>, value: unknown, label: string): Effect
 */
 export const readPairs = <R>(
  ctx: Interpreter<R>,
-  init: unknown,
+  init: Value,
  label: string,
 ): Effect.Effect<Array<[string, string]> | undefined, unknown, R> =>
  Effect.gen(function* () {
@@ -155,13 +155,13 @@ export const readPairs = <R>(
        if (pairs.some((entry) => entry.length !== 2)) throw typeError(`${label} expects iterable [name, value] pairs.`)
        return pairs as Array<[string, string]>
      }
-      pairs.push(yield* preserveConsumerError(cursor, readPair(ctx, step.value, label)))
+      pairs.push(yield* preserveConsumerError(cursor.close, readPair(ctx, step.value, label)))
    }
  })

 const constructURLSearchParams = <R>(
  ctx: Interpreter<R>,
-  init: unknown,
+  init: Value,
  proto: Obj,
 ): Effect.Effect<URLSearchParamsObj, unknown, R> => {
  const wrap = (params: URLSearchParams) => new URLSearchParamsObj(proto, params)
@@ -177,7 +177,6 @@ const constructURLSearchParams = <R>(
    if (isRuntimeReference(init)) {
      throw typeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.")
    }
-    if (isWrapper(init)) return wrap(new URLSearchParams())
    if (!(init instanceof Obj)) {
      throw typeError(
        "new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.",
@@ -197,11 +196,11 @@ export const urlSearchParamsGlobal = <R>(ctx: Interpreter<R>) => {
    call: requiresNew("URLSearchParams"),
    construct: (args, newTarget) => constructURLSearchParams(ctx, args[0], prototypeFrom(newTarget, proto)),
  })
-  const self = (thisValue: unknown, name: string) =>
+  const self = (thisValue: Value, name: string) =>
    receiver(URLSearchParamsObj, thisValue, `URLSearchParams.prototype.${name}`)
-  const wrap = (items: Array<unknown>) => new Arr(builtins.Array, items)
-  const arg = (args: Array<unknown>, index: number): string => coerceToString(args[index])
-  const requireArgs = (name: string, args: Array<unknown>, count: number): void => {
+  const wrap = (items: Array<Value>) => new Arr(builtins.Array, items)
+  const arg = (args: Array<Value>, index: number): string => coerceToString(args[index])
+  const requireArgs = (name: string, args: Array<Value>, count: number): void => {
    if (args.length < count) {
      throw typeError(`URLSearchParams.${name} requires ${count} argument${count === 1 ? "" : "s"}.`)
    }
@@ -270,19 +269,9 @@ export const urlSearchParamsGlobal = <R>(ctx: Interpreter<R>) => {
        return undefined
      },
    ],
-    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").params.keys())],
-    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").params.values())],
-    [
-      "entries",
-      0,
-      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
-          self(thisValue, "entries")
-            .params.entries()
-            .map(([key, value]) => wrap([key, value])),
-        ),
-    ],
+    ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").params.keys())],
+    ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").params.values())],
+    ["entries", 0, (thisValue) => hostIterator(builtins, self(thisValue, "entries").iterator(builtins))],
    ["toString", 0, (thisValue) => self(thisValue, "toString").params.toString()],
    [
      "forEach",
@@ -1,64 +1,13 @@
 import { fn } from "../interpreter/native.js"
 import { typeError } from "../interpreter/model.js"
-import {
-  get,
-  isWrapper,
-  type Native,
-  Arr,
-  Bytes,
-  DateObj,
-  ErrorObj,
-  MapObj,
-  RegExpObj,
-  SetObj,
-  URLObj,
-  URLSearchParamsObj,
-  HeadersObj,
-} from "../interpreter/objects.js"
+import { coerceToNumber, coerceToString, type Native, type Value } from "../interpreter/objects.js"
 import type { Interpreter } from "../interpreter/interpreter.js"

 export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="])

-/** The built-in string form of a value, without consulting program-defined `toString` methods. */
-export const coerceToString = (value: unknown): string => {
-  if (value === null) return "null"
-  if (value === undefined) return "undefined"
-  if (value instanceof DateObj) return Number.isFinite(value.time) ? new Date(value.time).toISOString() : "Invalid Date"
-  if (value instanceof RegExpObj) return `/${value.regex.source}/${value.regex.flags}`
-  if (value instanceof MapObj) return "[object Map]"
-  if (value instanceof SetObj) return "[object Set]"
-  if (value instanceof URLObj) return value.url.href
-  if (value instanceof URLSearchParamsObj) return value.params.toString()
-  if (value instanceof HeadersObj) return "[object Headers]"
-  if (value instanceof Bytes) return value.bytes.join(",")
-  if (value instanceof ErrorObj) {
-    // Match Error.prototype.toString: "name: message", or just one when the other is empty.
-    const name = get(value, "name")
-    const message = get(value, "message")
-    const shownName = typeof name === "string" ? name : "Error"
-    const shownMessage = typeof message === "string" ? message : ""
-    if (shownMessage === "") return shownName
-    if (shownName === "") return shownMessage
-    return `${shownName}: ${shownMessage}`
-  }
-  if (value instanceof Arr) {
-    return value.items.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",")
-  }
-  if (typeof value === "object") return "[object Object]"
-  return String(value)
-}
-
-export const coerceToNumber = (value: unknown): number => {
-  if (value instanceof DateObj) return value.time
-  if (value instanceof Bytes) return Number(coerceToString(value))
-  if (isWrapper(value)) return Number.NaN
-  if (value instanceof Arr) return Number(coerceToString(value))
-  return value !== null && typeof value === "object" ? Number.NaN : Number(value)
-}
-
 export type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN"

-const coerce = <R>(ctx: Interpreter<R>, name: Coercion, args: Array<unknown>): unknown => {
+const coerce = <R>(ctx: Interpreter<R>, name: Coercion, args: Array<Value>): Value => {
  // Native: Number() is 0 and String() is "", unlike their undefined-argument forms; the
  // other coercers match native through the undefined-argument path below.
  if (args.length === 0) {
@@ -66,15 +15,6 @@ const coerce = <R>(ctx: Interpreter<R>, name: Coercion, args: Array<unknown>): u
    if (name === "String") return ""
  }
  const raw = args[0]
-  if (isWrapper(raw)) {
-    if (name === "Boolean") return true
-    if (name === "Number") return coerceToNumber(raw)
-    if (name === "String") return coerceToString(raw)
-    if (name === "isFinite") return Number.isFinite(coerceToNumber(raw))
-    if (name === "isNaN") return Number.isNaN(coerceToNumber(raw))
-    if (name === "parseInt") return parseInt(coerceToString(raw))
-    return parseFloat(coerceToString(raw))
-  }
  if (name === "Number") return coerceToNumber(raw)
  if (name === "Boolean") return Boolean(raw)
  if (name === "isFinite") return Number.isFinite(coerceToNumber(raw))
@@ -1,9 +1,8 @@
 import { fn, methods } from "../interpreter/native.js"
 import { typeError } from "../interpreter/model.js"
-import { Bytes, Obj } from "../interpreter/objects.js"
+import { Bytes, Obj, coerceToString } from "../interpreter/objects.js"
 import { describeValue } from "../interpreter/references.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
-import { coerceToString } from "./value.js"

 // WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies. Invalid input is a
 // TypeError as well; browsers throw a DOMException named InvalidCharacterError, which CodeMode does not have.
@@ -192,6 +192,8 @@ export type Prepared<R = never> = {

 export type SearchEntry = {
  readonly description: ToolDescription
+  /** The path split into words, so `zones` matches `get_zones` as a word rather than as a substring of `timezones`. */
+  readonly pathWords: ReadonlyArray<string>
  readonly searchText: string
 }

@@ -247,6 +249,7 @@ const makeSearchTool = (searchIndex: ReadonlyArray<SearchEntry>): Tool => ({
                  (total, forms) =>
                    total +
                    (forms.some((form) => path === form || path.endsWith(`.${form}`)) ? 20 : 0) +
+                    (forms.some((form) => entry.pathWords.includes(form)) ? 12 : 0) +
                    (forms.some((form) => path.includes(form)) ? 8 : 0) +
                    (forms.some((form) => description.includes(form)) ? 4 : 0) +
                    (forms.some((form) => entry.searchText.includes(form)) ? 2 : 0),
@@ -281,6 +284,7 @@ export const searchSignature = (() => {

 const toSearchEntry = <R>(visible: VisibleTool<R>): SearchEntry => ({
  description: describeTool(visible),
+  pathWords: tokenize(visible.path),
  searchText: [
    visible.path,
    visible.tool.description,
@@ -1039,6 +1039,32 @@ describe("CodeMode public contract", () => {
    }
  })

+  test("a query term that is a whole word of the path outranks a substring of it", async () => {
+    const simple = (description: string) =>
+      Tool.make({
+        description,
+        input: Schema.Struct({}),
+        output: Schema.String,
+        execute: () => Effect.succeed("ok"),
+      })
+    const runtime = CodeMode.make({
+      tools: {
+        // Declared so that alphabetical order would put the substring match first.
+        cloudflare: { get_timezones: simple("List timezones"), get_zones: simple("List zones") },
+      },
+    })
+
+    const ranked = await Effect.runPromise(runtime.execute(`return search({ query: "zones" })`))
+    expect(ranked.ok).toBe(true)
+    if (ranked.ok) {
+      const value = ranked.value as { items: Array<{ path: string }> }
+      expect(value.items.map((item) => item.path)).toStrictEqual([
+        "tools.cloudflare.get_zones",
+        "tools.cloudflare.get_timezones",
+      ])
+    }
+  })
+
  test("a plural query term matches singular-only tool text", async () => {
    const simple = (description: string) =>
      Tool.make({
@@ -22,6 +22,16 @@ describe("source syntax", () => {
 })

 describe("error identity", () => {
+  test("Error.isError is true for every Error value and nothing else", async () => {
+    expect(
+      await value(`
+        const caught = (() => { try { null.foo } catch (error) { return error } })()
+        return [Error.isError(new Error("x")), Error.isError(new RangeError("x")), Error.isError(caught),
+          Error.isError({ name: "Error", message: "x" }), Error.isError("Error"), Error.isError(null)]
+      `),
+    ).toEqual([true, true, true, false, false, false])
+  })
+
  test("awaiting the same rejected promise twice yields the same error object", async () => {
    expect(
      await value(`
@@ -95,6 +105,24 @@ describe("uncaught program throws", () => {
  })
 })

+describe("source locations", () => {
+  test("uses the submitted line and 1-based column", async () => {
+    const failure = await error("const value = 1\nreturn value()")
+    expect(failure.location).toEqual({ line: 2, column: 8 })
+    expect(failure.message).toBe("TypeError: value is not a function. (line 2, col 8)")
+  })
+
+  test("names a missing method on a call instead of the previous line", async () => {
+    const failure = await error(`// Try search with different namespaces
+for (const ns of ["github", "tools.github", "tools", ""]) {
+  const s = await search({query: "star", namespace: ns, limit: 100}).catch(e=>({items:[],error:String(e)}));
+  return s
+}`)
+    expect(failure.location).toEqual({ line: 3, column: 19 })
+    expect(failure.message).toBe("TypeError: search(...).catch is not a function. (line 3, col 19)")
+  })
+})
+
 describe("host errors escaping built-ins", () => {
  test("become the same-named program error", async () => {
    expect(
@@ -107,7 +135,7 @@ describe("host errors escaping built-ins", () => {
  test("report the location of the call that raised them", async () => {
    const failure = await error(`return [1].map((n) => n.toFixed(200))`)
    expect(failure.kind).toBe("ExecutionFailure")
-    expect(failure.message).toBe("RangeError: toFixed() argument must be between 0 and 100 (line 1, col 19)")
+    expect(failure.message).toBe("RangeError: toFixed() argument must be between 0 and 100 (line 1, col 23)")
  })

  test("a built-in that rejects its arguments before doing any work is located at the call", async () => {
@@ -115,26 +143,26 @@ describe("host errors escaping built-ins", () => {
  })

  test("a rejection born inside a promise the built-in created is located at the creating call", async () => {
-    expect((await error(`return await Promise.all(1)`)).message).toEndWith("(line 1, col 10)")
-    expect((await error(`return await Promise.race([])`)).message).toEndWith("(line 1, col 10)")
+    expect((await error(`return await Promise.all(1)`)).message).toEndWith("(line 1, col 14)")
+    expect((await error(`return await Promise.race([])`)).message).toEndWith("(line 1, col 14)")
    expect((await error(`return await Promise.all({ [Symbol.iterator]: () => ({ next: 1 }) })`)).message).toEndWith(
-      "(line 1, col 10)",
+      "(line 1, col 14)",
    )
    expect((await error(`let p; p = Promise.resolve().then(() => p); return await p`)).message).toEndWith(
-      "(line 1, col 8)",
+      "(line 1, col 12)",
    )
  })

  test("an un-awaited rejection born inside promise machinery keeps its location in the warning", async () => {
    const result = await run(`Promise.all(1); return 1`)
    expect(result.ok && result.warnings?.[0]?.message).toEndWith(
-      "TypeError: Promise.all expects an array or other synchronous iterable. (line 1, col 1)",
+      "TypeError: Promise.all expects a synchronous iterable, received a number. (line 1, col 1)",
    )
  })

  test("a failure inside a built-in called by another built-in is located at the outer call", async () => {
    const failure = await error(`return Array.from({ [Symbol.iterator]: () => ({ next: 1 }) })`)
-    expect(failure.message).toBe("TypeError: Iterator next must be a function. (line 1, col 4)")
+    expect(failure.message).toBe("TypeError: Iterator next must be a function. (line 1, col 8)")
  })
 })

@@ -153,7 +181,7 @@ describe("call depth", () => {
  test("uncaught overflow reports the call that overflowed", async () => {
    const failure = await error(`const f = (n) => f(n + 1); return f(0)`)
    expect(failure.kind).toBe("ExecutionFailure")
-    expect(failure.message).toBe("RangeError: Maximum call stack size exceeded (line 1, col 14)")
+    expect(failure.message).toBe("RangeError: Maximum call stack size exceeded (line 1, col 18)")
  })

  test("the limit is 10000 nested calls", async () => {
@@ -529,6 +529,6 @@ describe("Test262 for-await-of adaptations", () => {
    const result = await execute(`for await (const item of { values: [1, 2] }) {}`)
    expect(result.ok).toBe(false)
    if (result.ok) return
-    expect(result.error.message).toContain("or custom iterator value")
+    expect(result.error.message).toContain("requires an iterable value, received a data object")
  })
 })
@@ -1030,7 +1030,7 @@ describe("confined generators", () => {
        const params = new URLSearchParams(entries())
        return [events, params.toString()]
      `),
-    ).toEqual([["first", "second", "pair close", "outer close"], "%5Bobject+Object%5D=2"])
+    ).toEqual([["first", "second", "pair close", "outer close"], "%5Bobject+Promise%5D=2"])
  })

  test("validates URLSearchParams pair lengths after converting the outer sequence", async () => {
@@ -1246,4 +1246,27 @@ describe("confined generators", () => {
      `),
    ).toEqual(["catch", "reaction"])
  })
+
+  test("a generator's return() through for...of or destructuring surfaces a failing close, as break does", async () => {
+    expect(
+      await value(`
+        const make = (ret) => ({ [Symbol.iterator]: () => ({ next: () => ({ done: false, value: [1] }), return: ret }) })
+        const blanks = (ret) => ({ [Symbol.iterator]: () => ({ next: () => ({ done: false }), return: ret }) })
+        const outcomes = []
+        for (const [label, ret] of [
+          ["null", () => null],
+          ["throws", () => { throw new RangeError("close") }],
+          ["ok", () => ({ done: true })],
+        ]) {
+          function* loop() { for (const [a] of make(ret)) yield a }
+          function* pattern() { for ([ {} = yield ] of [blanks(ret)]) {} }
+          for (const g of [loop(), pattern()]) {
+            g.next()
+            try { g.return(7); outcomes.push(label + " quiet") } catch (e) { outcomes.push(label + " " + e.constructor.name) }
+          }
+        }
+        return outcomes
+      `),
+    ).toEqual(["null TypeError", "null TypeError", "throws RangeError", "throws RangeError", "ok quiet", "ok quiet"])
+  })
 })
@@ -502,6 +502,12 @@ describe("CodeMode-specific array behavior", () => {
    expect(err.message).toContain("circular")
  })

+  test("indexOf and lastIndexOf with no argument search for undefined", async () => {
+    expect(await value(`return [1, undefined, 3].indexOf()`)).toBe(1)
+    expect(await value(`return [1, undefined, 3].lastIndexOf()`)).toBe(1)
+    expect(await value(`return [1, 2, 3].indexOf()`)).toBe(-1)
+  })
+
  test("keys/values/entries return iterators usable with for...of and spread", async () => {
    expect(await value(`return [...["x","y","z"].keys()]`)).toEqual([0, 1, 2])
    expect(await value(`return [...["x","y"].values()]`)).toEqual(["x", "y"])
@@ -940,6 +946,12 @@ describe("coercion parity: unknown static members read as undefined", () => {
    expect(await value(`try { JSON.rawJSON("1") } catch (e) { return e.message }`)).toBe(
      "JSON.rawJSON is not a function.",
    )
+    expect(await value(`try { search({ query: "star" }).catch(() => 1) } catch (e) { return e.message }`)).toBe(
+      "search(...).catch is not a function.",
+    )
+    expect(
+      await value(`const foo = () => ({ bar: () => ({}) }); try { foo().bar().baz() } catch (e) { return e.message }`),
+    ).toBe("foo(...).bar(...).baz is not a function.")
  })

  test("built-ins are objects on a real prototype chain", async () => {
@@ -961,6 +973,17 @@ describe("coercion parity: unknown static members read as undefined", () => {
  })
 })

+describe("async function line breaks", () => {
+  test("a line break between function and the name is an async function", async () => {
+    expect(await value(`async function\nfoo() { return 1 }\nreturn await foo()`)).toBe(1)
+  })
+
+  test("a line break between async and function is not an async function", async () => {
+    const failure = await error(`async\nfunction foo() { return 1 }\nreturn foo()`)
+    expect(failure.message).toContain("Unknown identifier 'async'")
+  })
+})
+
 describe("functions are objects", () => {
  test("name follows NamedEvaluation and length counts required parameters", async () => {
    expect(
@@ -730,7 +730,7 @@ describe("Promise.all over arbitrary arrays", () => {

  test("a non-collection argument is a clear error", async () => {
    const diagnostic = await error(`return await Promise.all(42)`)
-    expect(diagnostic.message).toContain("Promise.all expects an array")
+    expect(diagnostic.message).toContain("Promise.all expects a synchronous iterable, received a number")
  })

  test("exceeding maxToolCalls inside Promise.all is a ToolCallLimitExceeded diagnostic", async () => {
@@ -1131,8 +1131,43 @@ describe("unsupported promise surface", () => {
  })

  test("unknown Promise statics are not functions", async () => {
-    const diagnostic = await error(`return await Promise.withResolvers()`)
-    expect(diagnostic.message).toContain("Promise.withResolvers is not a function")
+    const diagnostic = await error(`return await Promise.settle(() => 1)`)
+    expect(diagnostic.message).toContain("Promise.settle is not a function")
+  })
+})
+
+describe("Promise.try", () => {
+  test("runs the function now with its arguments; a throw rejects, a return fulfils, a promise or thenable is adopted", async () => {
+    expect(
+      await value(`
+        const log = []
+        const sum = Promise.try((a, b) => { log.push("ran"); return a + b }, 1, 2)
+        log.push("after")
+        let caught
+        try { await Promise.try(() => { throw new RangeError("boom") }) } catch (e) { caught = e.constructor.name }
+        return [log, sum instanceof Promise, await sum, caught, await Promise.try(async () => 5), await Promise.try(() => ({ then: (r) => r("thenable") }))]
+      `),
+    ).toEqual([["ran", "after"], true, 3, "RangeError", 5, "thenable"])
+    expect((await error(`return Promise.try(5)`)).message).toContain(
+      "Promise.try expects a function, received a number.",
+    )
+  })
+})
+
+describe("Promise.withResolvers", () => {
+  test("returns a pending promise with resolvers that settle it once and adopt thenables", async () => {
+    expect(
+      await value(`
+        const first = Promise.withResolvers()
+        first.resolve(Promise.resolve("adopted"))
+        first.resolve("ignored")
+        const second = Promise.withResolvers()
+        second.reject(new Error("no"))
+        let caught
+        try { await second.promise } catch (e) { caught = e.message }
+        return [Object.keys(first), first.promise instanceof Promise, await first.promise, caught]
+      `),
+    ).toEqual([["promise", "resolve", "reject"], true, "adopted", "no"])
  })
 })

@@ -20,9 +20,9 @@ import { CodeMode, Tool } from "../src/index.js"

 // Standard-library value types: Date, RegExp, Map, Set. Programs use them as ordinary JS;
 // intra-CodeMode checkpoints (Object.* helpers, spread, coercion inputs) preserve the live
-// values, while at the host boundary (final result, tool arguments, JSON.stringify) they
-// serialize exactly as JSON.stringify would: Date -> ISO string (invalid -> null),
-// URL -> href, and RegExp/Map/Set/URLSearchParams -> {}.
+// values. JSON.stringify keeps Date -> ISO string (invalid -> null), URL -> href, and
+// RegExp/Map/Set/URLSearchParams -> {}. The host boundary matches that except URLSearchParams,
+// which cross as their query string, and Set, which crosses as an array.
 const run = (code: string) => Effect.runPromise(CodeMode.execute({ code, tools: {} }))
 const value = async (code: string) => {
  const result = await run(code)
@@ -898,6 +898,42 @@ describe("Map", () => {
    ).toEqual({ a: 3, b: 1, c: 1 })
  })

+  test("getOrInsert and getOrInsertComputed insert only when the key is missing", async () => {
+    expect(
+      await value(`
+      const groups = new Map()
+      groups.getOrInsert("a", []).push(1)
+      groups.getOrInsert("a", []).push(2)
+      let calls = 0
+      const computed = (key) => { calls++; return key + "!" }
+      const first = groups.getOrInsertComputed("b", computed)
+      const second = groups.getOrInsertComputed("b", computed)
+      const zero = groups.getOrInsertComputed(-0, (key) => 1 / key === Infinity)
+      return [[...groups], first, second, calls, zero]
+    `),
+    ).toEqual([
+      [
+        ["a", [1, 2]],
+        ["b", "b!"],
+        [0, true],
+      ],
+      "b!",
+      "b!",
+      1,
+      true,
+    ])
+    expect(
+      await value(`
+      const m = new Map()
+      const outer = m.getOrInsertComputed("k", () => { m.set("k", "inner"); return "outer" })
+      let thrown
+      try { m.getOrInsertComputed("j", () => { throw new Error("boom") }) } catch (error) { thrown = error.message }
+      return [outer, m.get("k"), thrown, m.has("j")]
+    `),
+    ).toEqual(["outer", "outer", "boom", false])
+    expect((await error(`new Map().getOrInsertComputed("k", 5)`)).message).toContain("expects a function callback")
+  })
+
  test("maps serialize to {} at the boundary, like JSON", async () => {
    expect(await value(`return new Map([["a", 1]])`)).toEqual({})
    expect(await value(`return JSON.stringify(new Map([["a", 1]]))`)).toBe("{}")
@@ -1061,7 +1097,7 @@ describe("Uint8Array", () => {
      console.log(b, new Uint8Array())
      return [String(b), b + "", +new Uint8Array([5]), Number.isNaN(Number(b)), b == "1,2", JSON.stringify(b), b.toLocaleString(), typeof b, b instanceof Uint8Array]
    `),
-    ).toEqual(["1,2", "1,2", 5, true, true, '{"0":1,"1":2}', "[object Uint8Array]", "object", true])
+    ).toEqual(["1,2", "1,2", 5, true, true, '{"0":1,"1":2}', "1,2", "object", true])
    expect((await run(`console.log(new Uint8Array([1, 2]), new Uint8Array())`)).logs).toEqual([
      "Uint8Array(2) [1,2] Uint8Array(0) []",
    ])
@@ -1129,6 +1165,147 @@ describe("TextEncoder and TextDecoder", () => {
  })
 })

+describe("Iterator helpers", () => {
+  test("lazy helpers chain over collection iterators and generators, one source step per result", async () => {
+    expect(
+      await value(`
+        const pulled = []
+        function* naturals() { let n = 0; while (true) { pulled.push(n); yield n++ } }
+        const squares = naturals().map((n) => n * n).filter((n) => n % 2 === 0).drop(1).take(3)
+        const first = squares.next()
+        return {
+          first,
+          rest: squares.toArray(),
+          after: squares.next(),
+          pulled,
+          values: new Map([["a", 1], ["b", 2]]).values().map((v, i) => v * 10 + i).toArray(),
+          flat: [1, 2].values().flatMap((n) => [n, [n]]).toArray(),
+          entries: [...new Map([[1, 2]]).entries().map(([k, v]) => k + v)],
+        }
+      `),
+    ).toEqual({
+      first: { value: 4, done: false },
+      rest: [16, 36],
+      after: { done: true },
+      pulled: [0, 1, 2, 3, 4, 5, 6],
+      values: [10, 21],
+      flat: [1, [1], 2, [2]],
+      entries: [3],
+    })
+  })
+
+  test("eager helpers consume the source and close it on early exit", async () => {
+    expect(
+      await value(`
+        const log = []
+        function* g() { try { yield 1; yield 2; yield 3 } finally { log.push("closed") } }
+        const seen = []
+        g().forEach((v, i) => seen.push([v, i]))
+        return {
+          seen,
+          sum: g().reduce((a, b) => a + b),
+          sumFrom: g().reduce((a, b) => a + b, 10),
+          some: g().some((v) => v === 2),
+          every: g().every((v) => v < 2),
+          find: g().find((v) => v > 1),
+          missing: g().find((v) => v > 5),
+          log,
+        }
+      `),
+    ).toEqual({
+      seen: [
+        [1, 0],
+        [2, 1],
+        [3, 2],
+      ],
+      sum: 6,
+      sumFrom: 16,
+      some: true,
+      every: false,
+      find: 2,
+      log: ["closed", "closed", "closed", "closed", "closed", "closed", "closed"],
+    })
+  })
+
+  test("a helper closes its source when a callback throws, on return(), and on early for...of exit", async () => {
+    expect(
+      await value(`
+        const log = []
+        function* g(name) { try { yield 1; yield 2 } finally { log.push(name) } }
+        const throwing = g("throw").map((v) => { if (v === 2) throw new Error("boom"); return v })
+        throwing.next()
+        let message
+        try { throwing.next() } catch (error) { message = error.message }
+        const returned = g("return").map((v) => v)
+        returned.next()
+        const closed = returned.return()
+        for (const v of g("loop").filter((v) => true)) break
+        return { message, afterThrow: throwing.next(), closed, afterReturn: returned.next(), log }
+      `),
+    ).toEqual({
+      message: "boom",
+      afterThrow: { done: true },
+      closed: { done: true },
+      afterReturn: { done: true },
+      log: ["throw", "return", "loop"],
+    })
+  })
+
+  test("collection iterators have no return() and continue after an early exit, as in JS", async () => {
+    expect(
+      await value(`
+        const it = [1, 2, 3].values()
+        const found = it.some((v) => v === 2)
+        return [typeof it.return, found, it.next().value, typeof it.map(x => x).return]
+      `),
+    ).toEqual(["undefined", true, 3, "function"])
+  })
+
+  test("Iterator.from and the abstract Iterator constructor", async () => {
+    expect(
+      await value(`
+        const it = [1].values()
+        let n = 0
+        const errors = []
+        for (const attempt of [() => Iterator(), () => new Iterator(), () => Iterator.from(5)]) {
+          try { attempt() } catch (error) { errors.push(error.name) }
+        }
+        return [
+          Iterator.from(it) === it,
+          Iterator.from("ab").toArray(),
+          Iterator.from([1, 2]).map((v) => v * 2).toArray(),
+          Iterator.from({ next: () => ({ done: n > 1, value: n++ }) }).toArray(),
+          it instanceof Iterator,
+          errors,
+        ]
+      `),
+    ).toEqual([true, ["a", "b"], [2, 4], [0, 1], true, ["TypeError", "TypeError", "TypeError"]])
+  })
+
+  test("argument validation", async () => {
+    const cases: Array<[string, string]> = [
+      ["[1].values().map(1)", "Iterator.prototype.map expects a function callback."],
+      ["[1].values().take(-1)", "Iterator.prototype.take expects a non-negative count, received -1."],
+      ["[1].values().drop()", "Iterator.prototype.drop expects a non-negative count, received NaN."],
+      [
+        "[1].values().flatMap((v) => 'ab').toArray()",
+        "Iterator.prototype.flatMap expects an iterable or iterator, received a string.",
+      ],
+      ["[].values().reduce((a, b) => a)", "Iterator.prototype.reduce of an empty iterator with no initial value."],
+    ]
+    for (const [code, message] of cases) {
+      expect((await error(`return ${code}`)).message).toContain(message)
+    }
+    expect(
+      await error(`
+        function* g() { while (true) yield 1 }
+        const it = g().map(() => it.next())
+        return it.next()
+      `),
+    ).toMatchObject({ message: expect.stringContaining("Iterator helper is already running.") })
+  })
+})
+
 describe("built-in iterators", () => {
  test("keys/values/entries and [Symbol.iterator] step with next() and stay live", async () => {
    expect(
@@ -1231,6 +1408,82 @@ describe("built-in iterators", () => {
  })
 })

+describe("Object.prototype.toString", () => {
+  test("reports the built-in kind it is inherited by, as JS does through Symbol.toStringTag", async () => {
+    expect(
+      await value(`
+      return [
+        new Map().toString(), new Set().toString(), new Headers().toString(), Promise.resolve(1).toString(),
+        [1].values().toString(), ({}).toString(), String(new Map()), String(Promise.resolve(1)),
+        \`\${new Set([1])}\`, [new Map()] + "", new Map() == "[object Map]",
+      ]
+    `),
+    ).toEqual([
+      "[object Map]",
+      "[object Set]",
+      "[object Headers]",
+      "[object Promise]",
+      "[object Iterator]",
+      "[object Object]",
+      "[object Map]",
+      "[object Promise]",
+      "[object Set]",
+      "[object Map]",
+      true,
+    ])
+  })
+})
+
+describe("console.log of errors", () => {
+  test("prints name and message, nested too", async () => {
+    const result = await run(`console.log(new Error("boom"), { e: new RangeError("r") })`)
+    expect(result.logs).toEqual(['Error: boom {"e":RangeError: r}'])
+  })
+})
+
+describe("toLocaleString", () => {
+  test("numbers and dates format as en-US in UTC; everything else falls back to toString", async () => {
+    expect(
+      await value(`
+      return [
+        (1234567.891).toLocaleString(), new Date(0).toLocaleString(), new Date(0).toLocaleDateString(),
+        new Date(0).toLocaleTimeString(), "a".toLocaleString(), true.toLocaleString(), ({}).toLocaleString(),
+        ({ toString: () => "custom" }).toLocaleString(), new Uint8Array([1, 2]).toLocaleString(),
+      ]
+    `),
+    ).toEqual([
+      "1,234,567.891",
+      "1/1/1970, 12:00:00 AM",
+      "1/1/1970",
+      "12:00:00 AM",
+      "a",
+      "true",
+      "[object Object]",
+      "custom",
+      "1,2",
+    ])
+  })
+
+  test("arrays join each element's toLocaleString, skipping holes and nullish elements", async () => {
+    expect(
+      await value(`
+      let calls = 0
+      const item = { toLocaleString() { calls++; return "o" } }
+      return [[1234.5, "x", null, undefined, item, new Date(0)].toLocaleString(), [, item, , item].toLocaleString(), calls]
+    `),
+    ).toEqual(["1,234.5,x,,,o,1/1/1970, 12:00:00 AM", ",o,,o", 3])
+    expect((await error(`const f = ({}).toLocaleString; f()`)).message).toContain(
+      "Object.prototype.toLocaleString called on null or undefined",
+    )
+  })
+
+  test("toLocaleLowerCase and toLocaleUpperCase ignore the locale argument", async () => {
+    expect(
+      await value(`return ["ABC".toLocaleLowerCase("tr"), "abc".toLocaleUpperCase(), "İ".toLocaleLowerCase()]`),
+    ).toEqual(["abc", "ABC", "i̇"])
+  })
+})
+
 describe("stdlib integration", () => {
  test("constructor follows own keys, shadowing, writes, and new", async () => {
    expect(
@@ -1,6 +1,6 @@
 {
  "revision": "250f204f23a9249ff204be2baec29600faae7b75",
-  "directories": ["built-ins/Array/prototype", "language/statements"],
+  "directories": ["built-ins/Array/prototype", "language/statements", "built-ins/Iterator"],
  "harness": ["assert.js", "sta.js", "compareArray.js", "doneprintHandle.js"],
  "flags": ["module", "raw", "noStrict"],
  "boundaries": {
@@ -101,6 +101,8 @@
    "legacy-regexp",
    "__proto__",
    "__getter__",
-    "__setter__"
+    "__setter__",
+    "iterator-sequencing",
+    "joint-iteration"
  ]
 }
@@ -9,7 +9,7 @@ import type { Interpreter } from "../../src/interpreter/interpreter.js"
 import { Throw } from "../../src/interpreter/model.js"
 import { createErrorValue } from "../../src/interpreter/intrinsics.js"
 import { constructor, fn, methods } from "../../src/interpreter/native.js"
-import { Callable, define, get, hidden, Arr, Fn, Obj } from "../../src/interpreter/objects.js"
+import { Callable, define, get, hidden, Arr, Fn, Obj, type Value } from "../../src/interpreter/objects.js"
 import { ToolRuntime } from "../../src/tool-runtime.js"

 export const root = import.meta.dir
@@ -64,10 +64,7 @@ export const run = async (file: string): Promise<Outcome> => {
  return { status: "pass" }
 }

-const harness = <R>(
-  ctx: Interpreter<R>,
-  onDone: (error: unknown) => void,
-): ReadonlyArray<readonly [string, unknown]> => {
+const harness = <R>(ctx: Interpreter<R>, onDone: (error: Value) => void): ReadonlyArray<readonly [string, Value]> => {
  const builtins = ctx.builtins
  const test262Prototype = new Obj(builtins.Object)
  define(test262Prototype, "name", "Test262Error", hidden)
@@ -90,7 +87,7 @@ const harness = <R>(
  methods(builtins, compareArray, [["format", 1, (_, args) => show(args[0])]])
  const assert = fn<R>(builtins, "assert", 2, (_, args) =>
    args[0] === true
-      ? Effect.void
+      ? Effect.undefined
      : fail(args[1] === undefined ? `Expected true but got ${show(args[0])}` : String(args[1])),
  )
  methods(builtins, assert, [
@@ -99,7 +96,7 @@ const harness = <R>(
      3,
      (_, args) =>
        Object.is(args[0], args[1])
-          ? Effect.void
+          ? Effect.undefined
          : fail(`${prefix(args[2])}Expected SameValue(«${show(args[0])}», «${show(args[1])}») to be true`),
    ],
    [
@@ -108,14 +105,14 @@ const harness = <R>(
      (_, args) =>
        Object.is(args[0], args[1])
          ? fail(`${prefix(args[2])}Expected SameValue(«${show(args[0])}», «${show(args[1])}») to be false`)
-          : Effect.void,
+          : Effect.undefined,
    ],
    [
      "compareArray",
      3,
      (_, args) =>
        compare(args[0], args[1])
-          ? Effect.void
+          ? Effect.undefined
          : fail(
              `Actual ${show(args[0])} and expected ${show(args[1])} should have the same contents. ${prefix(args[2])}`,
            ),
@@ -132,7 +129,7 @@ const harness = <R>(
              const thrown = materialize(ctx, Cause.squash(cause))
              if (!(thrown instanceof Obj)) return fail(`${prefix(args[2])}Thrown value was not an object!`)
              const actual = get(thrown, "constructor")
-              if (actual === args[0]) return Effect.void
+              if (actual === args[0]) return Effect.undefined
              return fail(`${prefix(args[2])}Expected a ${expected} but got a ${show(actual)}`)
            },
            onSuccess: () =>
@@ -146,7 +143,13 @@ const harness = <R>(
    ["assert", assert],
    ["compareArray", compareArray],
    ["Test262Error", test262Error],
-    ["$DONE", fn<R>(builtins, "$DONE", 1, (_, args) => onDone(args[0]))],
+    [
+      "$DONE",
+      fn<R>(builtins, "$DONE", 1, (_, args) => {
+        onDone(args[0])
+        return undefined
+      }),
+    ],
    [
      "$DONOTEVALUATE",
      fn<R>(builtins, "$DONOTEVALUATE", 0, () =>
@@ -225,7 +225,6 @@ built-ins/Array/prototype/splice/S15.4.4.12_A4_T1.js  # Array.prototype.splice c
 built-ins/Array/prototype/splice/S15.4.4.12_A4_T2.js  # Array.prototype.splice called on incompatible receiver a data object.
 built-ins/Array/prototype/splice/S15.4.4.12_A4_T3.js  # Array.prototype.splice called on incompatible receiver a data object.
 built-ins/Array/prototype/splice/create-ctor-non-object.js  # null value Expected a TypeError to be thrown but no exception was thrown at all
-built-ins/Array/prototype/toLocaleString/S15.4.4.3_A1_T1.js  # #1: var n = 0; var obj = {toLocaleString: function() {n++}}; var arr = [undefined, obj, null, obj, o
 built-ins/Array/prototype/toLocaleString/S15.4.4.3_A3_T1.js  # #1: var n = 0; var obj = {toLocaleString: function() {n++}}; Array.prototype[1] = obj; x = [obj]; x.
 built-ins/Array/prototype/toReversed/holes-not-preserved.js  # Actual [4, undefined, 2, undefined, 0] and expected [4, 3, 2, undefined, 0] should have the same con
 built-ins/Array/prototype/toSorted/holes-not-preserved.js  # Actual [1, 3, 4, undefined, undefined] and expected [1, 2, 3, 4, undefined] should have the same con
@@ -237,6 +236,11 @@ built-ins/Array/prototype/unshift/S15.4.4.13_A2_T3.js  # Array.prototype.unshift
 built-ins/Array/prototype/unshift/S15.4.4.13_A3_T2.js  # Array.prototype.unshift called on incompatible receiver a data object.
 built-ins/Array/prototype/unshift/S15.4.4.13_A4_T1.js  # Array.prototype.unshift called on incompatible receiver a data object.
 built-ins/Array/prototype/unshift/S15.4.4.13_A4_T2.js  # #3: Array.prototype[0] = 1; x = []; x.length = 1; x.unshift(0); x[1] === 1. Actual: undefined
+built-ins/Iterator/from/return-method-returns-iterator-result.js  # Iterator next must be a function.
+built-ins/Iterator/prototype/drop/limit-tonumber-throws.js  # Expected a Test262Error but got a RangeError
+built-ins/Iterator/prototype/drop/limit-tonumber.js  # Iterator.prototype.drop expects a non-negative count, received NaN.
+built-ins/Iterator/prototype/take/limit-tonumber-throws.js  # Expected a Test262Error but got a RangeError
+built-ins/Iterator/prototype/take/limit-tonumber.js  # Iterator.prototype.take expects a non-negative count, received NaN.
 language/statements/async-generator/dflt-params-abrupt.js  # Expected a Test262Error to be thrown but no exception was thrown at all
 language/statements/async-generator/dflt-params-ref-later.js  # Expected a ReferenceError to be thrown but no exception was thrown at all
 language/statements/async-generator/dflt-params-ref-self.js  # Expected a ReferenceError to be thrown but no exception was thrown at all
@@ -291,7 +295,6 @@ language/statements/for-await-of/async-func-decl-dstr-obj-empty-num.js  # TypeEr
 language/statements/for-await-of/async-func-decl-dstr-obj-empty-string.js  # TypeError: Object destructuring requires a data object or array value, received a string.
 language/statements/for-await-of/async-func-decl-dstr-obj-rest-number.js  # TypeError: Object destructuring requires a data object or array value, received a number.
 language/statements/for-await-of/async-func-decl-dstr-obj-rest-str-val.js  # TypeError: Object destructuring requires a data object or array value, received a string.
-language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-rtrn-close-null.js  # "Promise incorrectly fulfilled."
 language/statements/for-await-of/async-gen-decl-dstr-obj-empty-bool.js  # TypeError: Object destructuring requires a data object or array value, received a boolean.
 language/statements/for-await-of/async-gen-decl-dstr-obj-empty-num.js  # TypeError: Object destructuring requires a data object or array value, received a number.
 language/statements/for-await-of/async-gen-decl-dstr-obj-empty-string.js  # TypeError: Object destructuring requires a data object or array value, received a string.
@@ -299,10 +302,7 @@ language/statements/for-await-of/async-gen-decl-dstr-obj-rest-number.js  # TypeE
 language/statements/for-await-of/async-gen-decl-dstr-obj-rest-str-val.js  # TypeError: Object destructuring requires a data object or array value, received a string.
 language/statements/for-in/head-lhs-member.js  # Unsupported for...in binding.
 language/statements/for-of/dstr/array-elem-iter-rtrn-close-err.js  # Iterator next must be a function.
-language/statements/for-of/dstr/array-elem-iter-rtrn-close-null.js  # Expected a TypeError to be thrown but no exception was thrown at all
 language/statements/for-of/dstr/array-elem-iter-thrw-close-err.js  # Expected SameValue(«1», «0») to be true
-language/statements/for-of/dstr/array-elem-trlg-iter-list-rtrn-close-err.js  # Expected a Test262Error to be thrown but no exception was thrown at all
-language/statements/for-of/dstr/array-elem-trlg-iter-list-rtrn-close-null.js  # Expected a TypeError to be thrown but no exception was thrown at all
 language/statements/for-of/dstr/array-elem-trlg-iter-list-thrw-close-err.js  # Expected SameValue(«1», «0») to be true
 language/statements/for-of/dstr/array-elem-trlg-iter-rest-rtrn-close-err.js  # Expected a Test262Error to be thrown but no exception was thrown at all
 language/statements/for-of/dstr/array-elem-trlg-iter-rest-rtrn-close-null.js  # Expected a TypeError to be thrown but no exception was thrown at all
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-app",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/console-core",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-function",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-mail",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "dependencies": {
    "@jsx-email/all": "2.2.3",
    "@jsx-email/cli": "1.4.3",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-support",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "name": "@opencode/core",
  "type": "module",
  "license": "MIT",
@@ -6,15 +6,13 @@ import { Instructions } from "../instructions/index.js"
 import { CodeModeCatalog } from "./catalog.js"

 // prettier-ignore
-const prompt = (hasMoreTools: boolean) => `The Code Mode tool catalog below is ${hasMoreTools ? "partial" : "complete"}.
+const prompt = (hasMoreTools: boolean) => `# Code Mode

-${hasMoreTools ? "The Code Mode catalog and `search` results are" : "This catalog is"} the complete set of tools callable inside \`execute\`. It does not affect tools exposed directly outside Code Mode.${hasMoreTools ? `
+Use the \`execute\` tool to call the tools listed below. They cannot be called directly${hasMoreTools ? ", and neither can \`search\`. Both" : ". They"} only work inside code you pass to \`execute\`.

-## Search
+${hasMoreTools ? `The catalog is partial. Inside \`execute\`, use \`search(...)\` to find a tool, then call it by the \`path\` in the result. \`search\` is synchronous. Call it without \`await\`; it does not return a Promise. Do not guess tool names.

-Call \`search(...)\` to discover exact paths and signatures for additional tools:
-
- ${searchSignature}` : ""}
+- ${searchSignature}` : "The catalog is complete. Do not guess tool names."}

 ## Available tools`

@@ -4,6 +4,7 @@ import { define } from "@opencode/plugin/effect/plugin"
 import { Document } from "@opencode/schema/config"
 import { Effect } from "effect"
 import { Config } from "../../config.js"
+import { ManagedPolicy } from "../../managed-policy.js"
 import { Wildcard } from "../../util/wildcard.js"
 import { ConfigEntryObserver } from "./entry-observer.js"

@@ -11,16 +12,30 @@ export const Plugin = define({
  id: "opencode.config.policy",
  effect: Effect.fn(function* (ctx) {
    const config = yield* Config.Service
+    const managed = yield* ManagedPolicy.Service
    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, ctx.provider.reload())
-    const policies = () =>
-      loaded.entries
-        .filter((entry): entry is Document => entry.type === "document")
-        .toReversed()
-        .flatMap((entry) => entry.info.experimental?.policies ?? [])
+    // Authored documents reverse so user-global policy outranks repository policy; organization statements
+    // from the connected Console follow every authored one and have the final say.
+    const policies = () => {
+      const organization = managed.current()
+      return [
+        ...loaded.entries
+          .filter((entry): entry is Document => entry.type === "document")
+          .toReversed()
+          .flatMap((entry) => entry.info.experimental?.policies ?? [])
+          .map((policy) => ({ ...policy, message: "Blocked by configuration policy" })),
+        ...organization.statements.map((policy) => ({
+          ...policy,
+          message: organization.organization
+            ? `Blocked by ${organization.organization}'s policy`
+            : "Blocked by your organization's policy",
+        })),
+      ]
+    }
    yield* ctx.provider.transform((providers) => {
-      // User-global policy takes priority over policy authored by a repository.
+      const current = policies()
      for (const record of providers.list()) {
-        const policy = policies().findLast(
+        const policy = current.findLast(
          (policy) => policy.action === "provider.use" && Wildcard.match(record.provider.id, policy.resource),
        )
        if (policy?.effect === "deny") providers.remove(record.provider.id)
@@ -29,16 +44,17 @@ export const Plugin = define({
    yield* ctx.permission.hook("evaluate", (event) =>
      Effect.sync(() => {
        const current = policies()
-        const denied = event.resources.some((resource) => {
-          const policy = current.findLast(
-            (policy) =>
-              policy.action === "permission" && Wildcard.match(`${event.action}:${resource}`, policy.resource),
+        const denied = event.resources
+          .map((resource) =>
+            current.findLast(
+              (policy) =>
+                policy.action === "permission" && Wildcard.match(`${event.action}:${resource}`, policy.resource),
+            ),
          )
-          return policy?.effect === "deny"
-        })
+          .find((policy) => policy?.effect === "deny")
        if (!denied) return
        event.effect = "deny"
-        event.message = "Blocked by configuration policy"
+        event.message = denied.message
      }),
    )
  }),
@@ -0,0 +1,34 @@
+export * as ManagedPolicy from "./managed-policy.js"
+
+import { ConfigPolicy } from "@opencode/schema/config/policy"
+import { Context, Effect, Layer } from "effect"
+import { makeGlobalNode } from "@opencode/util/effect/app-node"
+
+/** Policy statements the connected OpenCode Console compiled for whoever it authenticated. */
+export interface State {
+  readonly statements: ReadonlyArray<ConfigPolicy.Info>
+  /** Organization name for denial messages, when the connection knows it. */
+  readonly organization?: string
+}
+
+export interface Interface {
+  /** Synchronous so catalog transforms can consult the statements while they run. */
+  readonly current: () => State
+  /** Replaces the whole state; statements never merge across connections. */
+  readonly set: (state: State) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/ManagedPolicy") {}
+
+const layer = Layer.sync(Service, () => {
+  const state: { current: State } = { current: { statements: [] } }
+  return Service.of({
+    current: () => state.current,
+    set: (next) =>
+      Effect.sync(() => {
+        state.current = next
+      }),
+  })
+})
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [] })
@@ -50,6 +50,7 @@ import { Integration } from "../integration.js"
 import { Job } from "../job.js"
 import { KV } from "../kv.js"
 import { Location } from "../location.js"
+import { ManagedPolicy } from "../managed-policy.js"
 import { ModelsDev } from "../models-dev.js"
 import { Mcp } from "../mcp/index.js"
 import { Npm } from "@opencode/util/npm"
@@ -92,6 +93,7 @@ import { PlanPlugin } from "./plan.js"
 import { ModelsDevPlugin } from "./models-dev.js"
 import { McpCodeModeExclusionPlugin } from "./mcp-codemode-exclusion.js"
 import { ProviderPlugins } from "./provider.js"
+import { OpencodePlugin } from "./provider/opencode.js"
 import { WebSearchPlugins } from "./websearch/index.js"
 import { SkillPlugin } from "./skill.js"
 import { VcsHgPlugin } from "./vcs/hg.js"
@@ -126,6 +128,7 @@ const services = [
  KV.Service,
  LLMClient.Service,
  Location.Service,
+  ManagedPolicy.Service,
  ModelsDev.Service,
  Mcp.Service,
  Npm.Service,
@@ -178,6 +181,7 @@ export const requirements = LayerNode.group([
  KV.node,
  llmClient,
  Location.node,
+  ManagedPolicy.node,
  ModelsDev.node,
  Mcp.node,
  Npm.node,
@@ -260,6 +264,10 @@ const post = [
  ConfigPolicyPlugin.Plugin,
 ] as const satisfies readonly InternalPlugin[]

+// Repository config must not switch off policy enforcement or the Console connection that delivers
+// organization statements, so plugin remove operations skip these IDs.
+export const guarded: ReadonlySet<string> = new Set([OpencodePlugin.id, ConfigPolicyPlugin.Plugin.id])
+
 export const list = Effect.fn("PluginInternal.list")(function* () {
  // Capture only services; activation supplies the child Scope and batching context.
  const context = Context.pick(...services)(yield* Effect.context<Requirements>())
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
jayair	b9b6f53d61	fix(app): hide cached panel divider	2026-09-21 23:02:42 +00:00
Aiden Cline	4cc9b90f27	fix(codemode): add Promise.try and surface a failing iterator close on generator return (#50419 )	2026-09-21 15:35:11 -05:00
James Long	990463aa9f	refactor(tui): favor dark theme base (#50412 )	2026-09-21 16:23:38 -04:00
opencode-agent[bot]andrekram1-node	cd39063622	test(core): stabilize browser idle attachment (#50418 ) Co-authored-by: rekram1-node <rekram1-node@users.noreply.github.com>	2026-09-21 14:45:33 -05:00
Aiden Cline	4c944a86d7	fix(core): tell the model search is synchronous (#50417 )	2026-09-21 14:35:46 -05:00
Aiden Cline	97e833a297	feat(codemode): add Iterator helpers and Iterator.from (#50410 )	2026-09-21 14:14:24 -05:00
xin zhuangandSimon Klee	b8aa08f260	fix(tui): complete Mini exit aliases (#50388 ) Co-authored-by: Simon Klee <hello@simonklee.dk>	2026-09-21 17:04:58 +00:00
Aiden Cline	3f0118022b	feat(codemode): add Promise.withResolvers, print errors in console, name values in iterable errors (#50389 )	2026-09-21 11:56:15 -05:00
Simon Klee	6f76c31ca7	tui: resize /btw dialog to terminal (#50392 )	2026-09-21 16:44:18 +00:00
Aiden Cline	f90beeb9b8	fix(core): say plainly that catalog tools and search only work inside execute (#50384 )	2026-09-21 11:13:33 -05:00
Adam	4b9a3d80fc	feat(core): enforce Console-managed policies (#49729 )	2026-09-21 11:10:57 -05:00
Aiden Cline	1316576720	refactor(codemode): type program values and let built-ins answer for themselves (#50191 )	2026-09-21 11:03:16 -05:00
opencode-agent[bot]andnexxeln	2f0c861af0	fix(cli): show actionable upgrade errors (#50346 ) Co-authored-by: nexxeln <95541290+nexxeln@users.noreply.github.com>	2026-09-21 19:09:56 +05:30
opencode-agent[bot]	4d94777d4d	chore(core): refresh bundled models.dev snapshot	2026-09-21 12:19:57 +00:00
opencode-agent[bot]	46ebde65e9	chore: update nix node_modules hashes	2026-09-21 11:58:21 +00:00
Luke Parker	932c12ad1d	chore(desktop): upgrade Electron to 44.4.3 (#50327 )	2026-09-21 21:33:49 +10:00
opencode	6f655dcbab	sync release versions for v2.0.12	2026-09-21 09:57:01 +00:00
Luke Parker	ab60f08c69	fix(app): open Review pane for browser focus in background sessions (#50284 )	2026-09-21 06:08:36 +00:00
Luke Parker	60ed84ecd1	feat(app): open agent-referenced files as rich artifact tabs (#49882 )	2026-09-21 15:20:15 +10:00
Luke Parker	8aebed170a	fix(app): show empty review state for projects without VCS (#50265 )	2026-09-21 14:54:47 +10:00
opencode-agent[bot]Brendonovich Kit Langton	14148a0ea4	fix(app): restore server status spacing (#50273 ) Co-authored-by: Brendonovich <14191578+Brendonovich@users.noreply.github.com> Co-authored-by: Kit Langton <kit.langton@gmail.com>	2026-09-21 12:37:19 +08:00
Aiden Cline	7f51fbd878	feat(codemode): rank whole-word path matches above substring matches in search (#50275 )	2026-09-20 22:59:01 -05:00
Aiden Cline	cbdd1f66da	fix(codemode): locate failures in the submitted source (#50197 )	2026-09-20 20:47:54 -05:00
Luke Parker	788eb0fa29	fix(cli): report fatal startup causes on stderr (#50240 )	2026-09-20 22:57:20 +00:00
opencode-agent[bot]andkitlangton	58fcad77a8	feat(tui): copy session ID from tab menu (#50181 ) Co-authored-by: kitlangton <7587245+kitlangton@users.noreply.github.com>	2026-09-20 19:15:37 +00:00
Aiden Cline	c555559ac1	refactor(plugin): name tool execution context (#50195 )	2026-09-20 11:36:19 -05:00
Aiden Cline	e3a3fa7108	fix(plugin): forward Promise tool cancellation (#50190 )	2026-09-20 11:22:49 -05:00
opencode-agent[bot]	6238af397e	chore(core): refresh bundled models.dev snapshot	2026-09-20 16:17:29 +00:00
Aiden Cline	7ffd75faf6	fix(core): restore anthropic budget variants (#50182 )	2026-09-20 10:50:21 -05:00
opencode-agent[bot]	1f8ab95695	chore(core): refresh bundled models.dev snapshot	2026-09-20 15:37:06 +00:00
Aiden Cline	62dc1f7696	feat(codemode): add toLocaleString, Error.isError, and Map.getOrInsert (#50098 )	2026-09-20 10:23:23 -05:00
opencode-agent[bot]	66f10ab7bf	chore(core): refresh bundled models.dev snapshot	2026-09-20 14:37:06 +00:00
opencode-agent[bot]	1ca8f63a79	chore(core): refresh bundled models.dev snapshot	2026-09-20 13:36:51 +00:00
opencode-agent[bot]	03bcdd580d	chore(core): refresh bundled models.dev snapshot	2026-09-20 12:43:39 +00:00
opencode-agent[bot]	cc502f7e5f	chore(core): refresh bundled models.dev snapshot	2026-09-20 11:37:37 +00:00
opencode-agent[bot]	64ce8771c0	chore(core): refresh bundled models.dev snapshot	2026-09-20 10:37:01 +00:00
opencode-agent[bot]	702a73d91a	chore(core): refresh bundled models.dev snapshot	2026-09-20 09:37:50 +00:00
opencode	991b727eb8	sync release versions for v2.0.11	2026-09-20 08:57:41 +00:00
opencode-agent[bot]	ba342ce227	chore(core): refresh bundled models.dev snapshot	2026-09-20 08:42:13 +00:00
David Hill	1464545665	fix(app): center timeline beside summary (#49620 )	2026-09-20 18:06:32 +10:00
David Hill	fecacc9e68	fix(app): match vertical nav tab states (#49619 )	2026-09-20 18:03:49 +10:00
David HillandLukeParkerDev	1f73b4806b	fix(desktop): polish browser panel states and navigation (#49432 ) Co-authored-by: LukeParkerDev <10430890+Hona@users.noreply.github.com>	2026-09-20 07:54:25 +00:00
opencode-agent[bot]	da2ce02596	chore(core): refresh bundled models.dev snapshot	2026-09-20 07:38:48 +00:00
opencode-agent[bot]	25f35dcfb8	chore(core): refresh bundled models.dev snapshot	2026-09-20 06:49:40 +00:00
Luke Parker	717f81ce08	chore(desktop): attribute renderer CPU profiles to source files (#50114 )	2026-09-20 16:30:35 +10:00
Luke Parker	5fdfcc7a80	perf(desktop): hand the window its persisted stores before the first render (#50113 )	2026-09-20 16:29:02 +10:00
Luke Parker	0530c8e512	perf(desktop): talk to the main process without the Effect runtime in the renderer (#50112 )	2026-09-20 16:26:08 +10:00
Luke Parker	1d8cf4564b	perf(desktop): move startup work that the first window does not need off its path (#50111 )	2026-09-20 16:23:37 +10:00
Luke Parker	7e88f6bb18	perf(desktop): bundle the renderer's initial module graph as one chunk (#50110 )	2026-09-20 16:19:28 +10:00
Luke Parker	af592fb779	perf(desktop): serve the renderer's first assets before evaluating the main bundle (#50109 )	2026-09-20 16:18:50 +10:00
Luke Parker	7fc3f68007	perf(desktop): boot the renderer alongside the main bundle (#50108 )	2026-09-20 16:15:58 +10:00
opencode-agent[bot]	cdcbb0047e	chore(core): refresh bundled models.dev snapshot	2026-09-20 05:38:29 +00:00
opencode-agent[bot]	a1956a7522	chore(core): refresh bundled models.dev snapshot	2026-09-20 04:42:05 +00:00
opencode-agent[bot]	55bc7fd403	chore(core): refresh bundled models.dev snapshot	2026-09-20 03:43:32 +00:00
opencode-agent[bot]	3049b1e684	chore(core): refresh bundled models.dev snapshot	2026-09-20 02:45:23 +00:00
opencode-agent[bot]	1f36a7aff8	chore(core): refresh bundled models.dev snapshot	2026-09-20 01:31:11 +00:00