refactor(app): port the model selection and terminal stores to plain codecs

refactor(app): port language, drafts, pairing, review panel, open-in-app and upsell stores to plain codecs
Also replaces the Effect Iterable pipeline in the provider catalog with array methods.
2026-09-21 08:07:34 +00:00 · 2026-09-20 16:37:02 +10:00 · 2026-09-20 16:37:01 +10:00 · 2026-09-20 16:37:00 +10:00 · 2026-09-20 16:37:00 +10:00 · 2026-09-20 16:36:59 +10:00
141 changed files with 3165 additions and 3423 deletions
@@ -32,7 +32,7 @@
    },
    "packages/ai": {
      "name": "@opencode/ai",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@aws-sdk/credential-providers": "3.1057.0",
        "@opencode/schema": "workspace:*",
@@ -54,7 +54,7 @@
    },
    "packages/app": {
      "name": "@opencode/app",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@corvu/drawer": "catalog:",
        "@dnd-kit/abstract": "0.5.0",
@@ -111,7 +111,7 @@
    },
    "packages/cli": {
      "name": "@opencode/cli",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "bin": {
        "opencode2": "./bin/opencode2.cjs",
      },
@@ -175,7 +175,7 @@
    },
    "packages/client": {
      "name": "@opencode/client",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@opencode/protocol": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -201,7 +201,7 @@
    },
    "packages/codemode": {
      "name": "@opencode/codemode",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "acorn": "8.15.0",
        "effect": "catalog:",
@@ -214,7 +214,7 @@
    },
    "packages/console/app": {
      "name": "@opencode/console-app",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "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.11",
+      "version": "2.0.10",
      "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.11",
+      "version": "2.0.10",
      "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.11",
+      "version": "2.0.10",
      "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.11",
+      "version": "2.0.10",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@opencode/console-core": "workspace:*",
@@ -338,7 +338,7 @@
    },
    "packages/core": {
      "name": "@opencode/core",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@ai-sdk/cohere": "3.0.27",
        "@ai-sdk/gateway": "3.0.104",
@@ -406,7 +406,7 @@
    },
    "packages/desktop": {
      "name": "@opencode/desktop",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@zip.js/zip.js": "2.7.62",
        "electron-context-menu": "4.1.2",
@@ -455,7 +455,7 @@
    },
    "packages/enterprise": {
      "name": "@opencode/enterprise",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@hono/standard-validator": "catalog:",
        "@opencode-ai/sdk": "1.18.21",
@@ -492,7 +492,7 @@
    },
    "packages/function": {
      "name": "@opencode/function",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@octokit/auth-app": "8.0.1",
        "@octokit/rest": "catalog:",
@@ -508,7 +508,7 @@
    },
    "packages/http-recorder": {
      "name": "@opencode/http-recorder",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@effect/platform-node-shared": "4.0.0-rc.112",
      },
@@ -527,7 +527,7 @@
    },
    "packages/httpapi-codegen": {
      "name": "@opencode/httpapi-codegen",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "effect": "catalog:",
        "prettier": "3.6.2",
@@ -540,7 +540,7 @@
    },
    "packages/latex": {
      "name": "@opencode/latex",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -554,7 +554,7 @@
    },
    "packages/merman": {
      "name": "@opencode/merman",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -569,7 +569,7 @@
    },
    "packages/plugin": {
      "name": "@opencode/plugin",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@ai-sdk/provider": "3.0.8",
        "@opencode/ai": "workspace:*",
@@ -608,7 +608,7 @@
    },
    "packages/plugin-browser": {
      "name": "@opencode/plugin-browser",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -638,7 +638,7 @@
    },
    "packages/protocol": {
      "name": "@opencode/protocol",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@opencode/schema": "workspace:*",
        "effect": "catalog:",
@@ -653,7 +653,7 @@
    },
    "packages/schema": {
      "name": "@opencode/schema",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@standard-schema/spec": "catalog:",
        "effect": "catalog:",
@@ -677,7 +677,7 @@
    },
    "packages/sdk": {
      "name": "@opencode/sdk",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -698,7 +698,7 @@
    },
    "packages/server": {
      "name": "@opencode/server",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@effect/platform-node": "catalog:",
        "@effect/platform-node-shared": "catalog:",
@@ -720,7 +720,7 @@
    },
    "packages/session-ui": {
      "name": "@opencode/session-ui",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode/client": "workspace:*",
@@ -755,7 +755,7 @@
    },
    "packages/simulation": {
      "name": "@opencode/simulation",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@opencode/ai": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -775,7 +775,7 @@
    },
    "packages/stats/app": {
      "name": "@opencode/stats-app",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@ibm/plex": "6.4.1",
        "@kobalte/core": "catalog:",
@@ -809,7 +809,7 @@
    },
    "packages/stats/core": {
      "name": "@opencode/stats-core",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "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.11",
+      "version": "2.0.10",
      "dependencies": {
        "@aws-sdk/client-firehose": "3.933.0",
        "@effect/platform-node": "catalog:",
@@ -874,7 +874,7 @@
    },
    "packages/theme": {
      "name": "@opencode/theme",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@opentui/core": "catalog:",
        "effect": "catalog:",
@@ -888,7 +888,7 @@
    },
    "packages/tui": {
      "name": "@opencode/tui",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -923,7 +923,7 @@
    },
    "packages/ui": {
      "name": "@opencode/ui",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@pierre/diffs": "catalog:",
@@ -958,7 +958,7 @@
    },
    "packages/util": {
      "name": "@opencode/util",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@effect/opentelemetry": "catalog:",
        "@effect/platform-node": "catalog:",
@@ -991,7 +991,7 @@
    },
    "packages/web": {
      "name": "@opencode/web",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "@astrojs/cloudflare": "12.6.3",
        "@astrojs/markdown-remark": "6.3.1",
@@ -1032,7 +1032,7 @@
    },
    "services/update": {
      "name": "@opencode/update",
-      "version": "2.0.11",
+      "version": "2.0.10",
      "dependencies": {
        "jose": "6.0.11",
        "semver": "catalog:",
@@ -2,7 +2,7 @@
  "$schema": "https://json.schemastore.org/package.json",
  "name": "opencode",
  "description": "AI-powered development tool",
-  "version": "2.0.11",
+  "version": "2.0.10",
  "private": true,
  "type": "module",
  "packageManager": "bun@1.4.2",
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.11",
+  "version": "2.0.10",
  "name": "@opencode/ai",
  "type": "module",
  "license": "MIT",
@@ -19,13 +19,6 @@ 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) => ({
@@ -54,33 +47,13 @@ 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: () => {
-        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],
-        }
-      },
+      active: () => tabs.find((tab) => tab.title === store.session) ?? tabs[0],
      registration: () => registrations.get(store.session),
-      error: () => store.error ?? (store.loadErrors[store.session] ? "Request failed" : undefined),
+      error: () => undefined,
      suspended: () => false,
      close: () => undefined,
      open: () => 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)
-      },
+      command: () => undefined,
    }
    return (
      <>
@@ -91,32 +64,6 @@ 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,153 +57,3 @@ 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()
-})
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/app",
-  "version": "2.0.11",
+  "version": "2.0.10",
  "description": "",
  "type": "module",
  "exports": {
@@ -3,7 +3,19 @@ import { checksum } from "@opencode/util/encode"
 import { SessionMessage } from "@opencode/schema/session-message"
 import { Skill } from "@opencode/schema/skill"
 import { Persistence } from "@/runtime/persistence/schema"
-import { FileSelection, SelectedLineRange } from "@/workspaces/files/types"
+// Effect twins of workspaces/files/types until this module moves to plain codecs.
+const SelectedLineRange = Persistence.struct({
+  start: Schema.Number,
+  end: Schema.Number,
+  side: Persistence.optional(Schema.Literals(["additions", "deletions"])),
+  endSide: Persistence.optional(Schema.Literals(["additions", "deletions"])),
+})
+const FileSelection = Persistence.struct({
+  startLine: Schema.Number,
+  startChar: Schema.Number,
+  endLine: Schema.Number,
+  endChar: Schema.Number,
+})

 const PartBase = {
  content: Schema.String,
@@ -228,3 +240,5 @@ export const PromptHistoryEntry = Schema.Union([HistoryEntry, HistoryPrompt]).pi
 export type PromptHistoryEntry = typeof PromptHistoryEntry.Type

 export const PromptHistoryState = Persistence.struct({ entries: Persistence.array(PromptHistoryEntry) })
+
+
@@ -11,15 +11,15 @@ import { Persist, persisted } from "@/runtime/persistence/storage"
 import { showToast } from "@/shell/notifications/toast"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { createResource } from "solid-js"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
+
 import type { HomeController } from "../model"
 import { useGlobal } from "@/runtime/server/runtime"
-import { SessionTransfer } from "@opencode/schema/session-transfer"
+
 import { useSshAuthenticate } from "@/servers/ssh/authenticate"

-export const HomeServersSchema = Schema.Struct({
-  collapsed: Persistence.record(Persistence.fallback(Schema.Boolean, () => false)),
+export const HomeServersSchema = Codec.struct({
+  collapsed: Codec.lenientRecord(Codec.fallback(Codec.boolean, () => false)),
 })

 export function createHomeProjectsController(home: HomeController) {
@@ -114,8 +114,13 @@ export function createHomeProjectsController(home: HomeController) {
              extensions: ["json"],
            },
            async (file) => {
-              const data = await Schema.decodeUnknownPromise(Schema.fromJsonString(SessionTransfer.Data))(
-                await file.text(),
+              // Validating an imported file is the one place the shared Effect schema is needed here.
+              const [{ Schema }, { SessionTransfer }] = await Promise.all([
+                import("effect"),
+                import("@opencode/schema/session-transfer"),
+              ])
+              const data = await Schema.decodeUnknownPromise(Schema.fromJsonString(SessionTransfer.Data))(
+                await file.text(),
              )
              const api = home.server.context(conn).sdk.api.session
              const imported = await api.import({
@@ -184,3 +189,4 @@ export function createHomeProjectsController(home: HomeController) {
 }

 export type HomeProjectsController = ReturnType<typeof createHomeProjectsController>
+
@@ -65,14 +65,14 @@
  }

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

      &:dir(rtl) {
-        --session-summary-translate: 160px;
+        --session-summary-translate: max(0px, calc(820px - 50cqi));
      }
    }
  }
@@ -5,7 +5,7 @@ import { Show, Suspense, createMemo, createSignal, lazy, onMount } from "solid-j
 import { createStore } from "solid-js/store"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { debounce } from "@solid-primitives/scheduled"
-import { Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import createPresence from "solid-presence"
 import { Composer } from "@/composer/composer"
 import { ComposerDropzone } from "@/composer/dropzone"
@@ -21,7 +21,6 @@ import { useWorkspaceLocation } from "@/workspaces/location"
 import { useProviders } from "@/providers/catalog/providers"
 import { NEW_SESSION_CONTENT_WIDTH } from "@/new-session/layout"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
 import type { NewSessionWorkspaceController } from "./workspace/controller"
 import { NewSessionWordmark } from "./wordmark"
 import { SummaryPopover } from "@/session/summary/popover"
@@ -34,12 +33,12 @@ const NewSessionSummary = lazy(async () => {

 const providerTipDismissalDuration = 30 * 24 * 60 * 60 * 1000

-export const WorkspaceOnboardingSchema = Persistence.struct({
-  used: Schema.Boolean,
+export const WorkspaceOnboardingSchema = Codec.struct({
+  used: Codec.boolean,
 })

-export const ProviderTipSchema = Persistence.struct({
-  dismissedAt: Schema.Finite,
+export const ProviderTipSchema = Codec.struct({
+  dismissedAt: Codec.number,
 })

 export const WorkspaceTipSchema = ProviderTipSchema
@@ -267,3 +266,4 @@ function NewSessionTips(props: { workspaceEligible: boolean; onWorkspace: () =>
    </Show>
  )
 }
+
@@ -1,7 +1,6 @@
 import { useData } from "@/runtime/server/current"
 import { useServerSDK } from "@/runtime/server/client"
 import { normalizeProviderList } from "@/runtime/server/global-sync/utils"
-import { Iterable, pipe } from "effect"
 import { createEffect, createMemo, type Accessor } from "solid-js"
 import type { ProviderListResponse } from "@/runtime/server/types"
 import { useIntegrations } from "./integrations"
@@ -53,34 +52,24 @@ export function useProviders(directory: Accessor<string | undefined>) {
        .filter((integration) => popularProviderSet.has(integration.id))
        .map((integration) => ({ id: integration.id, name: integration.name }))
      const seen = new Set(catalog.map((integration) => integration.id))
-      return pipe(
-        providers().all,
-        Iterable.map(([, p]) => p),
-        Iterable.filter((p) => popularProviderSet.has(p.id) && !seen.has(p.id)),
-        Iterable.map((p) => ({ id: p.id, name: p.name })),
-        (v) => [...catalog, ...v],
-      )
+      const more = [...providers().all.values()]
+        .filter((p) => popularProviderSet.has(p.id) && !seen.has(p.id))
+        .map((p) => ({ id: p.id, name: p.name }))
+      return [...catalog, ...more]
    },
    connected: () => {
      const connected = new Set(providers().connected)
-      return pipe(
-        providers().all,
-        Iterable.map(([, p]) => p),
-        Iterable.filter((p) => connected.has(p.id)),
-        (v) => Array.from(v),
-      )
+      return [...providers().all.values()].filter((p) => connected.has(p.id))
    },
    paid: () => {
      const connected = new Set(providers().connected)
-      const paid = [
-        ...Iterable.filter(
-          providers().all,
-          ([id]) =>
-            connected.has(id) &&
-            (id !== "opencode" || Object.values(providers().all.get(id)?.models ?? {}).some((m) => m.cost?.input)),
-        ),
-      ]
+      const paid = [...providers().all].filter(
+        ([id]) =>
+          connected.has(id) &&
+          (id !== "opencode" || Object.values(providers().all.get(id)?.models ?? {}).some((m) => m.cost?.input)),
+      )
      return paid
    },
  }
 }
+
@@ -3,12 +3,11 @@ import { base64Encode } from "@opencode/util/encode"
 import { useParams } from "@solidjs/router"
 import { batch, createEffect, createMemo, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
-import { Schema, SchemaGetter } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import { useModels } from "@/providers/models/models"
 import { useSettings } from "@/settings/model"
 import { useProviders } from "@/providers/catalog/providers"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
 import { hasCustomAgent, resolveAgent } from "./agent"
 import { cycleModelVariant, getConfiguredAgentVariant, resolveModelVariant } from "./variant"
 import { useWorkspaceLocation } from "@/workspaces/location"
@@ -18,46 +17,45 @@ import { useServerSDK } from "@/runtime/server/client"
 import { ScopedKey, type ServerScope } from "@/runtime/server/scope"
 import { useConfiguredModel } from "./configured"

-const ModelKeySchema = Schema.Struct({
-  providerID: Schema.String,
-  modelID: Schema.String,
-  variant: Schema.optional(Schema.String),
+const ModelKeySchema = Codec.struct({
+  providerID: Codec.string,
+  modelID: Codec.string,
+  variant: Codec.optional(Codec.string),
 })
 export type ModelKey = typeof ModelKeySchema.Type

-const ChoiceSchema = Schema.Struct({
-  model: Persistence.optional(ModelKeySchema),
-  variant: Persistence.optional(Schema.NullOr(Schema.String)),
+const ChoiceSchema = Codec.struct({
+  model: Codec.lenientOptional(ModelKeySchema),
+  variant: Codec.lenientOptional(Codec.nullOr(Codec.string)),
 })
-const StateSchema = Schema.Struct({
+const StateSchema = Codec.struct({
  ...ChoiceSchema.fields,
-  agent: Persistence.optional(Schema.String),
-  choices: Persistence.optional(Schema.Record(Schema.String, ChoiceSchema)),
+  agent: Codec.lenientOptional(Codec.string),
+  choices: Codec.lenientOptional(Codec.record(ChoiceSchema)),
 })
 type State = typeof StateSchema.Type

-const SessionsSchema = Schema.Record(
-  Schema.String,
-  Schema.mutableKey(Persistence.fallback(Schema.UndefinedOr(StateSchema), () => undefined)),
+const SessionsSchema = Codec.record(Codec.fallback(Codec.undefinedOr(StateSchema), () => undefined))
+
+const Current = Codec.struct({ session: SessionsSchema })
+const StoredSelection = Codec.struct(
+  {
+    session: Codec.lenientOptional(Codec.record(Codec.unknown)),
+    pick: Codec.lenientOptional(Codec.record(Codec.unknown)),
+  },
+  { preserve: true },
 )

-const Current = Persistence.struct({ session: SessionsSchema })
-
-export const ModelSelectionSchema = Persistence.migrate(
+export const ModelSelectionSchema = Codec.migrate(
  Current,
-  Schema.Struct({
-    session: Persistence.optional(Schema.Record(Schema.String, Schema.Unknown)),
-    pick: Persistence.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  }).pipe(
-    Schema.decode({
-      decode: SchemaGetter.transform((value) => ({
-        session:
-          value.session ??
-          Object.fromEntries(Object.entries(value.pick ?? {}).filter(([key]) => key !== WORKSPACE_KEY)),
-      })),
-      encode: SchemaGetter.transform((value) => value),
+  Codec.transform(StoredSelection, {
+    decode: (value) => ({
+      ...value,
+      session:
+        value.session ?? Object.fromEntries(Object.entries(value.pick ?? {}).filter(([key]) => key !== WORKSPACE_KEY)),
    }),
-  ),
+    encode: (value) => value,
+  }),
 )

 const WORKSPACE_KEY = "__workspace__"
@@ -906,10 +906,6 @@ 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",
@@ -1,7 +1,7 @@
 import { flatten, resolveTemplate, translator, type Flatten } from "@solid-primitives/i18n"
 import { createEffect, createMemo, createResource, type JSX } from "solid-js"
 import { createStore } from "solid-js/store"
-import { Option, Schema, SchemaGetter } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import { createSimpleContext } from "@opencode/ui/context"
 import {
  I18nProvider,
@@ -12,7 +12,6 @@ import {
  type UiPluralCategory,
 } from "@opencode/ui/context/i18n"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
 import en from "@/runtime/i18n/en"
 import { dict } from "@opencode/ui/i18n/en"
 import {
@@ -56,14 +55,9 @@ function cookie(locale: Locale) {

 const LOCALES: readonly Locale[] = DESKTOP_NATIVE_LOCALES

-const LocaleSchema = Schema.Literals(DESKTOP_NATIVE_LOCALES)
-const StoredLocaleSchema = Schema.Struct({
-  locale: Schema.String.pipe(
-    Schema.decodeTo(LocaleSchema, {
-      decode: SchemaGetter.transform(normalizeLocale),
-      encode: SchemaGetter.transform((locale) => locale),
-    }),
-  ),
+const LocaleSchema = Codec.literals(DESKTOP_NATIVE_LOCALES)
+const StoredLocaleSchema = Codec.struct({
+  locale: Codec.transform(Codec.string, { decode: normalizeLocale, encode: (locale) => locale }),
 })

 const INTL = DESKTOP_NATIVE_LOCALE_TAGS
@@ -160,11 +154,11 @@ function detectLocale(): Locale {
 }

 export function normalizeLocale(value: string): Locale {
-  return Option.getOrElse(Schema.decodeUnknownOption(LocaleSchema)(value), () => "en")
+  return Codec.decodeOption(LocaleSchema, value) ?? "en"
 }

-export const languageSchema = Persistence.struct({
-  locale: StoredLocaleSchema.fields.locale,
+export const languageSchema = Codec.struct({
+  locale: StoredLocaleSchema.fields.locale,
 })

 function readStoredLocale() {
@@ -172,9 +166,7 @@ function readStoredLocale() {
  try {
    const raw = localStorage.getItem("opencode.global.dat:language")
    if (!raw) return
-    const next = Schema.decodeUnknownOption(Schema.fromJsonString(StoredLocaleSchema))(raw)
-    if (Option.isNone(next)) return
-    return next.value.locale
+    return Codec.decodeOption(Codec.fromJsonString(StoredLocaleSchema), raw)?.locale
  } catch {
    return
  }
@@ -296,3 +288,4 @@ export function UiI18nBridge(props: { children?: JSX.Element }) {
    </I18nProvider>
  )
 }
+
@@ -0,0 +1,17 @@
+import { expect, test } from "bun:test"
+import { Codec } from "./codec"
+
+// Type-level checks: these compile only if inference matches what `typeof schema.Type` gave callers.
+test("struct types infer optional and required fields", () => {
+  const s = Codec.struct({ id: Codec.string, tab: Codec.optional(Codec.string), n: Codec.lenientOptional(Codec.number) })
+  const value: typeof s.Type = { id: "x" }
+  const tab: string | undefined = value.tab
+  const n: number | undefined = value.n
+  const t = Codec.transform(s, { decode: (old) => old.tab ?? old.id, encode: (v) => ({ id: v }) })
+  const out: string | Codec.Invalid = t.decode({ id: "a" })
+  const onlyOptional = Codec.struct({ tab: Codec.optional(Codec.string) })
+  const empty: typeof onlyOptional.Type = {}
+  const maybe: string | undefined = empty.tab
+  const viaTransform = Codec.transform(onlyOptional, { decode: (old) => old.tab, encode: (tab) => ({ tab }) })
+  expect([tab, n, out, maybe, viaTransform.decode({})]).toEqual([undefined, undefined, "a", undefined, undefined])
+})
@@ -0,0 +1,85 @@
+import { describe, expect, test } from "bun:test"
+import { Codec } from "./codec"
+
+describe("Codec", () => {
+  test("primitives reject the wrong shape and finite numbers only", () => {
+    expect(Codec.string.decode("a")).toBe("a")
+    expect(Codec.string.decode(1)).toBe(Codec.INVALID)
+    expect(Codec.number.decode(1.5)).toBe(1.5)
+    expect(Codec.number.decode(Number.NaN)).toBe(Codec.INVALID)
+    expect(Codec.nonNegativeInt.decode(-1)).toBe(Codec.INVALID)
+    expect(Codec.literals(["a", "b"]).decode("c")).toBe(Codec.INVALID)
+    expect(Codec.literal("x").decode("x")).toBe("x")
+  })
+
+  test("struct keeps optional fields absent and rejects invalid required ones", () => {
+    const codec = Codec.struct({ id: Codec.string, title: Codec.optional(Codec.string), n: Codec.lenientOptional(Codec.number) })
+    expect(codec.decode({ id: "1" })).toEqual({ id: "1" })
+    expect(codec.decode({ id: "1", title: "t", n: "bad" })).toEqual({ id: "1", title: "t" })
+    expect(codec.decode({ id: "1", title: 3 })).toBe(Codec.INVALID)
+    expect(codec.decode({ title: "t" })).toBe(Codec.INVALID)
+    expect(codec.decode([])).toBe(Codec.INVALID)
+    expect(codec.encode({ id: "1" })).toEqual({ id: "1" })
+    const value: typeof codec.Type = { id: "1", title: undefined }
+    expect(value.id).toBe("1")
+  })
+
+  test("lenient collections recover what they can", () => {
+    const items = Codec.lenientArray(Codec.struct({ id: Codec.string }))
+    expect(items.decode([{ id: "a" }, { id: 1 }, "x", { id: "b" }])).toEqual([{ id: "a" }, { id: "b" }])
+    expect(items.decode("nope")).toEqual([])
+    expect(Codec.array(Codec.string).decode(["a", 1])).toBe(Codec.INVALID)
+    const map = Codec.lenientRecord(Codec.boolean)
+    expect(map.decode({ a: true, b: "x" })).toEqual({})
+    expect(map.decode({ a: true })).toEqual({ a: true })
+  })
+
+  test("union, transform and fallback compose", () => {
+    const session = Codec.struct({ type: Codec.literal("session"), id: Codec.string })
+    const draft = Codec.struct({ type: Codec.literal("draft"), directory: Codec.string })
+    const tab = Codec.union([session, draft])
+    expect(tab.decode({ type: "draft", directory: "/x" })).toEqual({ type: "draft", directory: "/x" })
+    expect(tab.decode({ type: "other" })).toBe(Codec.INVALID)
+    const upper = Codec.transform(Codec.string, { decode: (s) => s.toUpperCase(), encode: (s) => s.toLowerCase() })
+    expect(upper.decode("ab")).toBe("AB")
+    expect(upper.encode("AB")).toBe("ab")
+    const safe = Codec.fallback(Codec.number, () => 7)
+    expect(safe.decode("x")).toBe(7)
+    expect(safe.decode(undefined)).toBe(7)
+    expect(safe.decode(2)).toBe(2)
+  })
+
+  test("brand constructs and decodes as its base", () => {
+    const Key = Codec.brand<"ServerConnection.Key">()
+    const key = Key.make("http://a")
+    expect(Key.decode(key)).toBe(key)
+    expect(Key.decode(3)).toBe(Codec.INVALID)
+  })
+
+  test("withInitial recovers field by field and merges new defaults", () => {
+    const layout = Codec.struct({
+      sidebar: Codec.struct({ opened: Codec.boolean, width: Codec.number }),
+      theme: Codec.lenientOptional(Codec.literals(["light", "dark"])),
+    })
+    const initial: typeof layout.Type = { sidebar: { opened: true, width: 240 } }
+    const codec = Codec.fromJsonString(Codec.withInitial(layout, initial))
+    expect(codec.decode(JSON.stringify({ sidebar: { opened: false, width: "wide" }, theme: "dark" }))).toEqual({
+      sidebar: { opened: false, width: 240 },
+      theme: "dark",
+    })
+    expect(codec.decode(JSON.stringify({ sidebar: 5 }))).toEqual(initial)
+    expect(codec.decode("{not json")).toBe(Codec.INVALID)
+    expect(JSON.parse(codec.encode({ sidebar: { opened: true, width: 1 } }))).toEqual({ sidebar: { opened: true, width: 1 } })
+  })
+
+  test("migrate reads the old shape first", () => {
+    const current = Codec.struct({ tabs: Codec.array(Codec.string) })
+    const previous = Codec.struct({ tab: Codec.optional(Codec.string) })
+    const read = Codec.transform(previous, {
+      decode: (old) => ({ tabs: old.tab ? [old.tab] : [] }),
+      encode: (value) => ({ tab: value.tabs[0] }),
+    })
+    const codec = Codec.withInitial(Codec.migrate(current, read), { tabs: [] })
+    expect(codec.decode({ tab: "a" })).toEqual({ tabs: ["a"] })
+  })
+})
@@ -0,0 +1,366 @@
+export * as Codec from "./codec"
+
+// Plain codecs for persisted state. They replace Effect Schema in the renderer's initial module
+// graph, where Effect's own module initialisation was the single largest startup cost that was not
+// rendering. Semantics mirror the Persistence helpers: decoding never throws, `INVALID` marks a
+// value that cannot be recovered, and the lenient combinators recover what they can.
+
+export const INVALID: unique symbol = Symbol.for("opencode/persistence/codec/invalid")
+export type Invalid = typeof INVALID
+
+const tag: unique symbol = Symbol.for("opencode/persistence/codec")
+
+export interface Of<T, E = unknown> {
+  readonly [tag]: true
+  /** Phantom: `typeof codec.Type` is the decoded type, as with Effect schemas. */
+  readonly Type: T
+  readonly Encoded: E
+  readonly optional?: boolean
+  decode(input: unknown): T | Invalid
+  encode(value: T): E
+}
+
+export type Any = Of<any, any>
+export type Type<C extends Any> = C["Type"]
+
+export function isCodec(value: unknown): value is Any {
+  return typeof value === "object" && value !== null && tag in value
+}
+
+export function make<T, E = unknown>(decode: (input: unknown) => T | Invalid, encode: (value: T) => E): Of<T, E> {
+  return { [tag]: true, decode, encode } as Of<T, E>
+}
+
+export function is<T>(codec: Of<T>, input: unknown): input is T {
+  return codec.decode(input) !== INVALID
+}
+
+export function decodeOption<T>(codec: Of<T>, input: unknown): T | undefined {
+  const value = codec.decode(input)
+  return value === INVALID ? undefined : value
+}
+
+export function decodeOrThrow<T>(codec: Of<T>, input: unknown): T {
+  const value = codec.decode(input)
+  if (value === INVALID) throw new Error("Value does not match its codec")
+  return value
+}
+
+/** Encodes and checks the result decodes, so an invalid in-memory value fails loudly instead of persisting. */
+export function encodeOrThrow<T, E>(codec: Of<T, E>, value: T): E {
+  const encoded = codec.encode(value)
+  if (codec.decode(encoded) === INVALID) throw new Error("Value does not match its codec")
+  return encoded
+}
+
+const identity = <T>(value: T) => value
+
+export const string: Of<string, string> = make((v) => (typeof v === "string" ? v : INVALID), identity)
+export const boolean: Of<boolean, boolean> = make((v) => (typeof v === "boolean" ? v : INVALID), identity)
+export const unknown: Of<unknown, unknown> = make((v) => v, identity)
+/** Finite numbers only: NaN and infinities are not JSON and never valid state. */
+export const number: Of<number, number> = make((v) => (typeof v === "number" && Number.isFinite(v) ? v : INVALID), identity)
+export const int: Of<number, number> = make((v) => (typeof v === "number" && Number.isInteger(v) ? v : INVALID), identity)
+export const nonNegativeInt: Of<number, number> = make(
+  (v) => (typeof v === "number" && Number.isInteger(v) && v >= 0 ? v : INVALID),
+  identity,
+)
+
+export function literal<const L extends string | number | boolean | null>(value: L): Of<L, L> {
+  return make((v) => (v === value ? value : INVALID), identity)
+}
+
+export function literals<const L extends ReadonlyArray<string | number | boolean | null>>(values: L): Of<L[number], L[number]> {
+  const set = new Set<unknown>(values)
+  return make((v) => (set.has(v) ? (v as L[number]) : INVALID), identity)
+}
+
+/** A string carrying a nominal brand, with the constructor Effect's `Schema.brand` gave callers. */
+export function brand<B extends string>(): Of<string & { readonly [K in B]: B }, string> & {
+  make(value: string): string & { readonly [K in B]: B }
+} {
+  return Object.assign(make<string & { readonly [K in B]: B }, string>((v) => (typeof v === "string" ? (v as never) : INVALID), identity), {
+    make: (value: string) => value as never,
+  })
+}
+
+export function nullOr<T, E>(codec: Of<T, E>): Of<T | null, E | null> {
+  return make((v) => (v === null ? null : codec.decode(v)), (v) => (v === null ? null : codec.encode(v)))
+}
+
+export function undefinedOr<T, E>(codec: Of<T, E>): Of<T | undefined, E | undefined> {
+  return make((v) => (v === undefined ? undefined : codec.decode(v)), (v) => (v === undefined ? undefined : codec.encode(v)))
+}
+
+/** A struct field that may be absent. Present but invalid values make the struct invalid. */
+export function optional<T, E>(codec: Of<T, E>): Of<T | undefined, E | undefined> & { readonly optional: true } {
+  return { ...undefinedOr(codec), optional: true } as never
+}
+
+/** A struct field that may be absent, and whose invalid values are dropped rather than rejected. */
+export function lenientOptional<T, E>(codec: Of<T, E>): Of<T | undefined, E | undefined> & { readonly optional: true } {
+  return {
+    ...make<T | undefined, E | undefined>(
+      (v) => {
+        if (v === undefined) return undefined
+        const value = codec.decode(v)
+        return value === INVALID ? undefined : value
+      },
+      (v) => (v === undefined ? undefined : codec.encode(v)),
+    ),
+    optional: true,
+  } as never
+}
+
+type Fields = Record<string, Any>
+type OptionalKeys<F extends Fields> = { [K in keyof F]: F[K] extends { optional: true } ? K : never }[keyof F]
+type RequiredKeys<F extends Fields> = Exclude<keyof F, OptionalKeys<F>>
+type Simplify<T> = { [K in keyof T]: T[K] } & {}
+export type StructType<F extends Fields> = Simplify<
+  { [K in RequiredKeys<F>]: F[K]["Type"] } & { [K in OptionalKeys<F>]?: F[K]["Type"] }
+>
+export type StructEncoded<F extends Fields> = Simplify<
+  { [K in RequiredKeys<F>]: F[K]["Encoded"] } & { [K in OptionalKeys<F>]?: F[K]["Encoded"] }
+>
+
+export interface Struct<F extends Fields> extends Of<StructType<F>, StructEncoded<F>> {
+  readonly fields: F
+}
+
+// `preserve` keeps keys the struct does not declare, for migration shapes that only describe the
+// fields they rewrite (Effect's `onExcessProperty: "preserve"`); the current schema then decides.
+export function struct<const F extends Fields>(fields: F, options?: { preserve?: boolean }): Struct<F> {
+  const entries = Object.entries(fields)
+  return {
+    ...make<StructType<F>, StructEncoded<F>>(
+      (input) => {
+        if (typeof input !== "object" || input === null || Array.isArray(input)) return INVALID
+        const record = input as Record<string, unknown>
+        const out: Record<string, unknown> = options?.preserve ? { ...record } : {}
+        for (const [key, codec] of entries) {
+          const present = Object.hasOwn(record, key)
+          if (!present && codec.optional) continue
+          const value = codec.decode(record[key])
+          if (value === INVALID) return INVALID
+          if (value !== undefined || present) out[key] = value
+          else delete out[key]
+        }
+        return out as StructType<F>
+      },
+      (value) => {
+        const out: Record<string, unknown> = {}
+        for (const [key, codec] of entries) {
+          const field = (value as Record<string, unknown>)[key]
+          if (field === undefined && !Object.hasOwn(value as object, key)) continue
+          out[key] = codec.encode(field)
+        }
+        return out as StructEncoded<F>
+      },
+    ),
+    fields,
+  }
+}
+
+export function array<T, E>(codec: Of<T, E>): Of<T[], E[]> {
+  return make(
+    (input) => {
+      if (!Array.isArray(input)) return INVALID
+      const out: T[] = []
+      for (const item of input) {
+        const value = codec.decode(item)
+        if (value === INVALID) return INVALID
+        out.push(value)
+      }
+      return out
+    },
+    (value) => value.map((item) => codec.encode(item)),
+  )
+}
+
+/** Keeps the items that decode and drops the rest, like `Persistence.array`. */
+export function lenientArray<T, E>(codec: Of<T, E>): Of<T[], E[]> {
+  return make(
+    (input) => {
+      if (!Array.isArray(input)) return []
+      return input.flatMap((item) => {
+        const value = codec.decode(item)
+        return value === INVALID ? [] : [value]
+      })
+    },
+    (value) => value.map((item) => codec.encode(item)),
+  )
+}
+
+export function record<T, E>(codec: Of<T, E>): Of<Record<string, T>, Record<string, E>> {
+  return make(
+    (input) => {
+      if (typeof input !== "object" || input === null || Array.isArray(input)) return INVALID
+      const out: Record<string, T> = {}
+      for (const [key, item] of Object.entries(input)) {
+        const value = codec.decode(item)
+        if (value === INVALID) return INVALID
+        out[key] = value
+      }
+      return out
+    },
+    (value) => Object.fromEntries(Object.entries(value).map(([key, item]) => [key, codec.encode(item)])),
+  )
+}
+
+/** A record that drops entries whose values are invalid, the replacement for `catchDecoding` to none. */
+export function sparseRecord<T, E>(codec: Of<T, E>): Of<Record<string, T>, Record<string, E>> {
+  return make(
+    (input) => {
+      if (typeof input !== "object" || input === null || Array.isArray(input)) return INVALID
+      const out: Record<string, T> = {}
+      for (const [key, item] of Object.entries(input)) {
+        const value = codec.decode(item)
+        if (value !== INVALID) out[key] = value
+      }
+      return out
+    },
+    (value) => Object.fromEntries(Object.entries(value).map(([key, item]) => [key, codec.encode(item)])),
+  )
+}
+
+/** An invalid record becomes empty rather than failing the whole store, like `Persistence.record`. */
+export function lenientRecord<T, E>(codec: Of<T, E>): Of<Record<string, T>, Record<string, E>> {
+  const strict = record(codec)
+  return make(
+    (input) => {
+      const value = strict.decode(input)
+      return value === INVALID ? {} : value
+    },
+    strict.encode,
+  )
+}
+
+export function union<const C extends ReadonlyArray<Any>>(codecs: C): Of<C[number]["Type"], C[number]["Encoded"]> {
+  return make(
+    (input) => {
+      for (const codec of codecs) {
+        const value = codec.decode(input)
+        if (value !== INVALID) return value
+      }
+      return INVALID
+    },
+    (value) => {
+      // Encode with the first member that accepts the value's shape; members are disjoint in practice.
+      for (const codec of codecs) if (codec.decode(value) !== INVALID) return codec.encode(value)
+      return value as C[number]["Encoded"]
+    },
+  )
+}
+
+/** Maps a decoded value into another shape, the replacement for `decodeTo` + `SchemaGetter.transform`. */
+export function transform<T, E, T2>(
+  codec: Of<T, E>,
+  options: { decode: (value: T) => T2; encode: (value: T2) => T },
+): Of<T2, E> {
+  return make(
+    (input) => {
+      const value = codec.decode(input)
+      return value === INVALID ? INVALID : options.decode(value)
+    },
+    (value) => codec.encode(options.encode(value)),
+  )
+}
+
+/** Decodes with `source`, maps, then validates with `target`: Effect's `decodeTo` with a transform. */
+export function decodeTo<T, E, T2, E2>(
+  source: Of<T, E>,
+  target: Of<T2, E2>,
+  options: { decode: (value: T) => E2; encode: (value: T2) => T },
+): Of<T2, E> {
+  return make(
+    (input) => {
+      const value = source.decode(input)
+      return value === INVALID ? INVALID : target.decode(options.decode(value))
+    },
+    (value) => source.encode(options.encode(value)),
+  )
+}
+
+/** Invalid and missing values become `value()`, like `Persistence.fallback`. */
+export function fallback<T, E>(codec: Of<T, E>, value: () => NoInfer<T>): Of<T, E> {
+  return make(
+    (input) => {
+      if (input === undefined) return value()
+      const decoded = codec.decode(input)
+      return decoded === INVALID ? value() : decoded
+    },
+    codec.encode,
+  )
+}
+
+export function fromJsonString<T, E>(codec: Of<T, E>): Of<T, string> {
+  return make(
+    (input) => {
+      if (typeof input !== "string") return INVALID
+      try {
+        return codec.decode(JSON.parse(input))
+      } catch {
+        return INVALID
+      }
+    },
+    (value) => JSON.stringify(codec.encode(value)),
+  )
+}
+
+export type Decoder = Pick<Of<unknown>, "decode">
+export type Migrated<C extends Any> = { readonly current: C; readonly read: Decoder }
+
+/** Older stored shapes go through `read` first; `current` describes what the store holds today. */
+export function migrate<C extends Any>(current: C, read: Decoder): Migrated<C> {
+  return { current, read }
+}
+
+function isMigrated<C extends Any>(definition: C | Migrated<C>): definition is Migrated<C> {
+  return !isCodec(definition) && "current" in definition
+}
+
+// Stored values recover field by field against the initial value: an object's valid fields are
+// kept, invalid or missing ones take their initial counterpart, and the result is merged over the
+// initial so new fields appear with their defaults. Mirrors `Persistence.withInitial`.
+export function withInitial<C extends Any>(definition: C | Migrated<C>, initial: Type<C>): Of<Type<C>, unknown> {
+  const codec = isMigrated(definition) ? definition.current : definition
+  const read = isMigrated(definition) ? definition.read : unknown
+  return make(
+    (input) => {
+      const stored = read.decode(input)
+      if (stored === INVALID) return INVALID
+      return merge(initial, recover(codec, stored, initial))
+    },
+    (value) => codec.encode(value),
+  )
+}
+
+function recover(codec: Any, value: unknown, initial: unknown): unknown {
+  if (value === undefined) return initial
+  if ("fields" in codec && isObject(value)) {
+    const fields = (codec as Struct<Fields>).fields
+    return Object.fromEntries(
+      Object.entries(fields).flatMap(([name, field]) => {
+        const defaults = isObject(initial) ? initial[name] : undefined
+        const next = recover(field, value[name], defaults)
+        if (next === undefined && !Object.hasOwn(value, name) && defaults === undefined) return []
+        return [[name, next]]
+      }),
+    )
+  }
+  const decoded = codec.decode(value)
+  return decoded === INVALID ? initial : decoded
+}
+
+function merge(initial: unknown, value: unknown): unknown {
+  if (value === undefined) return initial
+  if (!isObject(initial) || !isObject(value)) return value
+  return Object.fromEntries(
+    [...new Set([...Object.keys(initial), ...Object.keys(value)])].map((key) => [key, merge(initial[key], value[key])]),
+  )
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
@@ -3,6 +3,7 @@ import { Schema } from "effect"
 import { WorkspaceOnboardingSchema, ProviderTipSchema, WorkspaceTipSchema } from "@/new-session/view"
 import { ModelSelectionSchema } from "@/providers/models/selection"
 import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { FileViewsSchema } from "@/workspaces/files/view-cache"
 import { languageSchema } from "@/runtime/i18n/language"
 import { HomeServersSchema } from "@/home/projects/controller"
@@ -10,9 +11,9 @@ import { ModelProvidersSchema } from "@/settings/models/models"

 describe("persisted consumer schemas", () => {
  test("onboarding and provider tip retain defaults and validate stored values", () => {
-    const onboarding = Schema.decodeUnknownSync(Persistence.withInitial(WorkspaceOnboardingSchema, { used: false }))
-    const tip = Schema.decodeUnknownSync(Persistence.withInitial(ProviderTipSchema, { dismissedAt: 0 }))
-    const workspaceTip = Schema.decodeUnknownSync(Persistence.withInitial(WorkspaceTipSchema, { dismissedAt: 0 }))
+    const onboarding = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(WorkspaceOnboardingSchema, { used: false }), input))
+    const tip = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(ProviderTipSchema, { dismissedAt: 0 }), input))
+    const workspaceTip = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(WorkspaceTipSchema, { dismissedAt: 0 }), input))
    expect(onboarding({})).toEqual({ used: false })
    expect(onboarding({ used: "true" })).toEqual({ used: false })
    expect(onboarding({ used: true })).toEqual({ used: true })
@@ -25,7 +26,7 @@ describe("persisted consumer schemas", () => {

  test("collapse records recover malformed entries without losing valid siblings", () => {
    for (const schema of [HomeServersSchema, ModelProvidersSchema]) {
-      const decode = Schema.decodeUnknownSync(Persistence.withInitial(schema, { collapsed: {} }))
+      const decode = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(schema, { collapsed: {} }), input)
      expect(decode({})).toEqual({ collapsed: {} })
      expect(decode({ collapsed: [] })).toEqual({ collapsed: {} })
      expect(decode({ collapsed: { open: false, closed: true, invalid: "false" } })).toEqual({
@@ -35,21 +36,19 @@ describe("persisted consumer schemas", () => {
  })

  test("model selection migrates legacy picks and omits workspace state", () => {
-    const decode = Schema.decodeUnknownSync(Persistence.withInitial(ModelSelectionSchema, { session: {} }))
+    const decode = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(ModelSelectionSchema, { session: {} }), input)
    expect(decode({})).toEqual({ session: {} })
    const state = decode({ pick: { __workspace__: { agent: "plan" }, session1: { agent: "build" } } })
    expect(state.session.session1?.agent).toBe("build")
    expect(state.session.__workspace__).toBeUndefined()
-    const encoded = Schema.encodeSync(
-      Schema.fromJsonString(Persistence.withInitial(ModelSelectionSchema, { session: {} })),
-    )(state)
+    const encoded = Codec.fromJsonString(Codec.withInitial(ModelSelectionSchema, { session: {} })).encode(state)
    expect(JSON.parse(encoded)).toEqual({ session: { session1: { agent: "build" } } })
    expect(decode(JSON.parse(encoded))).toEqual(state)
  })

  test("current model selections take precedence over legacy picks", () => {
    expect(
-      Schema.decodeUnknownSync(Persistence.withInitial(ModelSelectionSchema, { session: {} }))({
+      Codec.decodeOrThrow(Codec.withInitial(ModelSelectionSchema, { session: {} }), {
        session: {},
        pick: { session1: { agent: "plan" } },
      }),
@@ -57,7 +56,7 @@ describe("persisted consumer schemas", () => {
  })

  test("model selection validates nested model keys and preserves explicit null variants", () => {
-    const state = Schema.decodeUnknownSync(Persistence.withInitial(ModelSelectionSchema, { session: {} }))({
+    const state = Codec.decodeOrThrow(Codec.withInitial(ModelSelectionSchema, { session: {} }), {
      session: {
        good: { agent: "build", model: { providerID: "provider", modelID: "model", variant: "high" }, variant: null },
        partial: { agent: "plan", model: { providerID: "provider", modelID: 42 }, variant: false },
@@ -76,7 +75,7 @@ describe("persisted consumer schemas", () => {
  })

  test("file views validate scroll positions and line sides independently", () => {
-    const decode = Schema.decodeUnknownSync(Persistence.withInitial(FileViewsSchema, { file: {} }))
+    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(FileViewsSchema, { file: {} }), input))
    expect(decode({})).toEqual({ file: {} })
    const state = decode({
      file: {
@@ -103,7 +102,7 @@ describe("persisted consumer schemas", () => {
  })

  test("language preserves runtime defaults and normalizes unsupported locales to English", () => {
-    const decode = Schema.decodeUnknownSync(Persistence.withInitial(languageSchema, { locale: "fr" }))
+    const decode = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(languageSchema, { locale: "fr" }), input)
    expect(decode({})).toEqual({ locale: "fr" })
    expect(decode({ locale: undefined })).toEqual({ locale: "fr" })
    expect(decode({ locale: 42 })).toEqual({ locale: "fr" })
@@ -111,3 +110,6 @@ describe("persisted consumer schemas", () => {
    expect(decode({ locale: "ar" })).toEqual({ locale: "ar" })
  })
 })
+
+
+
@@ -1,5 +1,5 @@
 import type { AsyncStorage } from "@solid-primitives/storage"
-import { Option, Schema } from "effect"
+import { Codec } from "./codec"

 export type BlobReference = { id: string; url: string }

@@ -312,12 +312,12 @@ export function createDraftStore(driver: Driver, options: { grace?: number } = {
    getItem: async (key) => {
      const value = await driver.get(key)
      if (value === null) return null
-      const parsed = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown))(value)
-      // Let the owning persistence codec apply its invalid-document policy.
-      if (Option.isNone(parsed)) return value
-      // A loaded document is live in the composer: pin its images before decode mints their URLs.
-      retain(key, imageIDs(parsed.value), grace)
-      return JSON.stringify(await decode(parsed.value))
+      const parsed = Codec.fromJsonString(Codec.unknown).decode(value)
+      // Let the owning persistence codec apply its invalid-document policy.
+      if (parsed === Codec.INVALID) return value
+      // A loaded document is live in the composer: pin its images before decode mints their URLs.
+      retain(key, imageIDs(parsed), grace)
+      return JSON.stringify(await decode(parsed))
    },
    setItem: (key, value) => setDocument(key, JSON.parse(value)),
    setDocument,
@@ -455,3 +455,4 @@ export async function blobDataUrl(blob: BlobReference, mime: string) {
 export function createLegacyBlobReference(dataUrl: string): BlobReference {
  return { id: dataUrl, url: dataUrl }
 }
+
@@ -6,6 +6,7 @@ import { createStore, type SetStoreFunction, type Store } from "solid-js/store"
 import { Option, Schema } from "effect"
 import { pathKey } from "@/workspaces/path-key"
 import { ScopedKey, ServerScope } from "@/runtime/server/scope"
+import { Codec } from "./codec"
 import { persistStore } from "./persist"
 import { Persistence } from "./schema"

@@ -472,25 +473,57 @@ export function removePersisted(
  }
 }

-export function persisted<S extends Schema.ConstraintCodec<object, unknown>>(
+type Definition<S extends Schema.ConstraintCodec<object, unknown> | Codec.Any> =
+  | S
+  | Persistence.Migrated<Extract<S, Schema.ConstraintCodec<object, unknown>>>
+  | Codec.Migrated<Extract<S, Codec.Any>>
+
+// Persisted stores are moving from Effect Schema to the plain codecs in ./codec so the renderer
+// stops paying for Effect at startup; both are accepted while the migration is underway.
+function serializer<S extends Schema.ConstraintCodec<object, unknown> | Codec.Any>(
+  definition: Definition<S>,
+  initial: S["Type"],
+) {
+  if (Codec.isCodec(definition) || (!("current" in definition) ? false : Codec.isCodec(definition.current))) {
+    const codec = Codec.withInitial(definition as Codec.Any | Codec.Migrated<Codec.Any>, initial)
+    const json = Codec.fromJsonString(codec)
+    return {
+      decode: (raw: string) => Codec.decodeOption(json, raw) as S["Type"] | undefined,
+      deserialize: (raw: unknown) => Codec.decodeOrThrow(json, raw) as S["Type"],
+      serialize: (value: S["Type"]) => Codec.encodeOrThrow(json, value),
+      encode: (value: S["Type"]) => Codec.encodeOrThrow(codec, value),
+      initial: Codec.decodeOrThrow(codec, codec.encode(initial)) as S["Type"],
+    }
+  }
+  const schema = definition as Schema.ConstraintCodec<object, unknown> | Persistence.Migrated<Schema.ConstraintCodec<object, unknown>>
+  const initialized = Persistence.withInitial(schema, initial as object)
+  const json = Schema.fromJsonString(initialized)
+  const decode = Schema.decodeUnknownOption(json)
+  return {
+    decode: (raw: string) => Option.getOrUndefined(decode(raw)) as S["Type"] | undefined,
+    deserialize: Schema.decodeUnknownSync(json) as (raw: unknown) => S["Type"],
+    serialize: Schema.encodeSync(json) as (value: S["Type"]) => string,
+    encode: Schema.encodeSync(initialized) as (value: S["Type"]) => unknown,
+    initial: Schema.decodeUnknownSync(Schema.toType(initialized))(initial as object) as S["Type"],
+  }
+}
+
+export function persisted<S extends Schema.ConstraintCodec<object, unknown> | Codec.Any>(
  target: string | PersistTarget,
-  schema: S | Persistence.Migrated<S>,
+  schema: Definition<S>,
  initial: NoInfer<S["Type"]>,
  platformOverride?: Platform,
 ): PersistedWithReady<S["Type"]> {
  const platform = platformOverride ?? usePlatform()
  const config = resolveTarget(typeof target === "string" ? { key: target } : target, platform)

-  const initialized = Persistence.withInitial(schema, initial)
-  const json = Schema.fromJsonString(initialized)
-  const decode = Schema.decodeUnknownOption(json)
-  const encode = Schema.encodeSync(initialized)
-  const serialize = Schema.encodeSync(json)
+  const codec = serializer<S>(schema, initial)
+  const { encode, serialize } = codec
  const normalize = (raw: string) => {
-    const value = decode(raw)
-    if (Option.isSome(value)) return serialize(value.value)
+    const value = codec.decode(raw)
+    if (value !== undefined) return serialize(value)
  }
-  const store = createStore<S["Type"]>(Schema.decodeUnknownSync(Schema.toType(initialized))(initial))
+  const store = createStore<S["Type"]>(codec.initial)
  const isDesktop = platform.platform === "desktop" && !!platform.storage
  const draft = config.draft ? platform.draftStore : undefined
  const prefix = `${config.storage ?? "default"}:`
@@ -602,7 +635,7 @@ export function persisted<S extends Schema.ConstraintCodec<object, unknown>>(
    name: config.key,
    storage,
    serialize,
-    deserialize: Schema.decodeUnknownSync(json),
+    deserialize: codec.deserialize,
    sync: channel ? messageSync(channel) : undefined,
    // Drafts take the encoded document itself so large text is externalized without the store
    // re-parsing the serialized form on every save.
@@ -0,0 +1,11 @@
+import type { Brand } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
+
+// The server key's brand is shared with the Effect schema in ./persistence.ts (type only, so this
+// module loads nothing of Effect), letting stores port to plain codecs one at a time.
+export type ServerKey = string & Brand.Brand<"ServerConnection.Key">
+
+export const ServerKey: Codec.Of<ServerKey, string> & { make(value: string): ServerKey } = Object.assign(
+  Codec.make<ServerKey, string>((v) => (typeof v === "string" ? (v as ServerKey) : Codec.INVALID), (v) => v),
+  { make: (value: string) => value as ServerKey },
+)
@@ -1,15 +1,14 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
 import { IconState, ModelState, ProjectState, VcsState, serverState } from "./persistence"
 import { createRoot } from "solid-js"
 import { isServer } from "solid-js/web"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"

 const initial = { list: [], hidden: {}, projects: {}, lastProject: {}, recentlyClosed: {} }

 function serverSchema(canonical?: () => string | undefined) {
-  return Persistence.withInitial(serverState(canonical), initial)
+  return Codec.withInitial(serverState(canonical), initial)
 }

 describe("server persistence schema", () => {
@@ -29,7 +28,7 @@ describe("server persistence schema", () => {
      ],
      projects: { local: [{ worktree: "/project", expanded: true }] },
    }
-    const state = Schema.decodeUnknownSync(schema)(input)
+    const state = Codec.decodeOrThrow(schema, input)
    expect(state).toEqual({
      list: [
        { type: "http", http: { url: "http://localhost:4096" } },
@@ -48,13 +47,13 @@ describe("server persistence schema", () => {
      recentlyClosed: {},
    })
    expect(input.list[1]).toHaveProperty("username", "legacy")
-    const encoded = Schema.encodeSync(schema)(state)
+    const encoded = schema.encode(state)
    expect(encoded).toEqual(state)
-    expect(Schema.decodeUnknownSync(schema)(encoded)).toEqual(state)
+    expect(Codec.decodeOrThrow(schema, encoded)).toEqual(state)
  })

  test("defaults missing or malformed fields and drops invalid entries independently", () => {
-    const decode = Schema.decodeUnknownSync(serverSchema())
+    const decode = ((input: unknown) => Codec.decodeOrThrow(serverSchema(), input))
    const empty = { list: [], hidden: {}, projects: {}, lastProject: {}, recentlyClosed: {} }
    expect(decode({})).toEqual(empty)
    expect(decode({ list: null, hidden: [], projects: false, lastProject: 1, recentlyClosed: "bad" })).toEqual(empty)
@@ -74,7 +73,7 @@ describe("server persistence schema", () => {

  test("moves canonical project buckets without changing server keys or unrelated scopes", () => {
    const schema = serverSchema(() => "https://opencode.example.com")
-    const state = Schema.decodeUnknownSync(schema)({
+    const state = Codec.decodeOrThrow(schema, {
      list: ["https://opencode.example.com"],
      hidden: { "https://opencode.example.com": true },
      projects: {
@@ -100,14 +99,14 @@ describe("server persistence schema", () => {
    expect(state.list[0]?.http.url).toBe("https://opencode.example.com")
    expect(state.hidden).toEqual({ "https://opencode.example.com": true })
    expect(state.recentlyClosed).toEqual({ local: ["/closed"], "https://opencode.example.com": ["/old-closed"] })
-    expect(Schema.encodeSync(schema)(state)).toEqual(state)
-    expect(Schema.decodeUnknownSync(schema)(state)).toEqual(state)
+    expect(schema.encode(state)).toEqual(state)
+    expect(Codec.decodeOrThrow(schema, state)).toEqual(state)
  })

  test("reads the latest canonical local prop on each decode", () => {
    const props: { canonicalLocalServer?: string } = {}
    const schema = serverSchema(() => props.canonicalLocalServer)
-    const decode = Schema.decodeUnknownSync(schema)
+    const decode = ((input: unknown) => Codec.decodeOrThrow(schema, input))
    const input = {
      projects: { remote: [{ worktree: "/project", expanded: true }] },
      lastProject: { remote: "/project" },
@@ -122,7 +121,7 @@ describe("server persistence schema", () => {
  })

  test("migrates a last project without a project list", () => {
-    expect(Schema.decodeUnknownSync(serverSchema(() => "remote"))({ lastProject: { remote: "/project" } })).toEqual({
+    expect(Codec.decodeOrThrow(serverSchema(() => "remote"), { lastProject: { remote: "/project" } })).toEqual({
      list: [],
      hidden: {},
      projects: {},
@@ -134,7 +133,7 @@ describe("server persistence schema", () => {

 describe("model persistence schema", () => {
  test("defaults missing state and keeps valid entries beside malformed entries", () => {
-    const decode = Schema.decodeUnknownSync(Persistence.withInitial(ModelState, { user: [], recent: [], variant: {} }))
+    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(ModelState, { user: [], recent: [], variant: {} }), input))
    expect(decode({})).toEqual({ user: [], recent: [], variant: {} })
    expect(decode({ user: null, recent: 1, variant: [] })).toEqual({ user: [], recent: [], variant: {} })
    const state = decode({
@@ -155,24 +154,24 @@ describe("model persistence schema", () => {
      recent: [{ providerID: "provider", modelID: "model" }],
      variant: { model: "high" },
    })
-    expect(Schema.encodeSync(ModelState)(state)).toEqual(state)
+    expect(ModelState.encode(state)).toEqual(state)
  })
 })

 describe("directory cache schemas", () => {
  test("defaults missing and malformed VCS caches but retains optional branch metadata", () => {
-    const decode = Schema.decodeUnknownSync(Persistence.withInitial(VcsState, { value: undefined }))
+    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(VcsState, { value: undefined }), input))
    expect(decode({})).toEqual({ value: undefined })
    expect(decode({ value: null })).toEqual({ value: undefined })
    expect(decode({ value: { branch: 1 } })).toEqual({ value: undefined })
    expect(decode({ value: { default_branch: "main" } })).toEqual({ value: { default_branch: "main" } })
    const state = decode({ value: { branch: "feature", default_branch: "main", obsolete: true } })
    expect(state).toEqual({ value: { branch: "feature", default_branch: "main" } })
-    expect(Schema.encodeSync(VcsState)(state)).toEqual(state)
+    expect(VcsState.encode(state)).toEqual(state)
  })

  test("validates project name, icon overrides and startup commands", () => {
-    const decode = Schema.decodeUnknownSync(Persistence.withInitial(ProjectState, { value: undefined }))
+    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(ProjectState, { value: undefined }), input))
    expect(decode({})).toEqual({ value: undefined })
    expect(decode({ value: [] })).toEqual({ value: undefined })
    expect(decode({ value: { icon: { override: 1 } } })).toEqual({ value: undefined })
@@ -185,7 +184,7 @@ describe("directory cache schemas", () => {
        commands: { start: "bun dev" },
      },
    })
-    expect(Schema.encodeSync(ProjectState)(state)).toEqual(state)
+    expect(ProjectState.encode(state)).toEqual(state)
    expect(state.value).toEqual({
      name: "Project",
      icon: { override: "data:image/png;base64,abc", color: "blue" },
@@ -194,12 +193,12 @@ describe("directory cache schemas", () => {
  })

  test("validates optional icon strings", () => {
-    const decode = Schema.decodeUnknownSync(Persistence.withInitial(IconState, { value: undefined }))
+    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(IconState, { value: undefined }), input))
    expect(decode({})).toEqual({ value: undefined })
    expect(decode({ value: 42 })).toEqual({ value: undefined })
    expect(decode({ value: null })).toEqual({ value: undefined })
    expect(decode({ value: "" })).toEqual({ value: "" })
-    expect(Schema.encodeSync(IconState)(decode({ value: "data:image/png;base64,abc" }))).toEqual({
+    expect(IconState.encode(decode({ value: "data:image/png;base64,abc" }))).toEqual({
      value: "data:image/png;base64,abc",
    })
  })
@@ -255,7 +254,7 @@ test.skipIf(isServer)(
      const stored = values.get("opencode.global.dat:server")
      expect(stored).toBeDefined()
      if (!stored) throw new Error("server state was not written")
-      const decoded = Schema.decodeUnknownSync(Schema.fromJsonString(serverSchema()))(stored)
+      const decoded = Codec.decodeOrThrow(Codec.fromJsonString(serverSchema()), stored)
      expect(decoded.projects.local).toEqual([{ worktree: "/project", expanded: true }])
      expect(stored).not.toContain("username")
      expect(decoded.list).toEqual(root.state[0].list)
@@ -264,3 +263,4 @@ test.skipIf(isServer)(
    }
  },
 )
+
@@ -1,136 +1,127 @@
-import { Effect, Option, Schema, SchemaGetter } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
+import { ServerKey } from "./key"

-export const ServerKey = Schema.String.pipe(Schema.brand("ServerConnection.Key"))
+export { ServerKey }

-export const ServerHttpBase = Persistence.struct({
-  url: Schema.String,
-  password: Schema.optional(Schema.String),
+export const ServerHttpBase = Codec.struct({
+  url: Codec.string,
+  password: Codec.optional(Codec.string),
 })

-export const ServerHttp = Persistence.struct({
-  type: Schema.Literal("http"),
+export const ServerHttp = Codec.struct({
+  type: Codec.literal("http"),
  http: ServerHttpBase,
-  authToken: Schema.optional(Schema.Boolean),
-  displayName: Schema.optional(Schema.String),
-  label: Schema.optional(Schema.String),
+  authToken: Codec.optional(Codec.boolean),
+  displayName: Codec.optional(Codec.string),
+  label: Codec.optional(Codec.string),
 })

-const StoredServer = Schema.Union([ServerHttp, ServerHttpBase, Schema.String]).pipe(
-  Schema.decodeTo(ServerHttp, {
-    decode: SchemaGetter.transform((value) => {
-      if (typeof value === "string") return { type: "http", http: { url: value } }
-      if ("http" in value) return value
-      return { type: "http", http: value }
-    }),
-    encode: SchemaGetter.transform((value) => value),
-  }),
-)
-
-const ProjectList = Persistence.array(
-  Persistence.struct({
-    worktree: Schema.String,
-    expanded: Persistence.fallback(Schema.Boolean, () => true),
-  }),
-)
-const Projects = Persistence.record(ProjectList)
-const LastProject = Persistence.record(Schema.String.pipe(Schema.catchDecoding(() => Effect.succeed(Option.none()))))
-
-const State = Persistence.struct({
-  list: Persistence.array(StoredServer),
-  hidden: Schema.Record(
-    Schema.String,
-    Schema.mutableKey(Schema.Boolean.pipe(Schema.catchDecoding(() => Effect.succeed(Option.none())))),
-  ),
-  projects: Schema.Record(Schema.String, Schema.mutableKey(ProjectList)),
-  lastProject: Schema.Record(
-    Schema.String,
-    Schema.mutableKey(Schema.String.pipe(Schema.catchDecoding(() => Effect.succeed(Option.none())))),
-  ),
-  recentlyClosed: Schema.Record(Schema.String, Schema.mutableKey(Persistence.array(Schema.String))),
+// Servers were stored as a URL string, then as the HTTP block alone, before the current shape.
+const StoredServer = Codec.decodeTo(Codec.union([ServerHttp, ServerHttpBase, Codec.string]), ServerHttp, {
+  decode: (value) => {
+    if (typeof value === "string") return { type: "http" as const, http: { url: value } }
+    if ("http" in value) return value
+    return { type: "http" as const, http: value }
+  },
+  encode: (value) => value,
 })

+const ProjectList = Codec.lenientArray(
+  Codec.struct({
+    worktree: Codec.string,
+    expanded: Codec.fallback(Codec.boolean, () => true),
+  }),
+)
+const Projects = Codec.lenientRecord(ProjectList)
+const LastProject = Codec.fallback(Codec.sparseRecord(Codec.string), () => ({}))
+
+const State = Codec.struct({
+  list: Codec.lenientArray(StoredServer),
+  hidden: Codec.sparseRecord(Codec.boolean),
+  projects: Codec.record(ProjectList),
+  lastProject: Codec.sparseRecord(Codec.string),
+  recentlyClosed: Codec.record(Codec.lenientArray(Codec.string)),
+})
+
+const StoredState = Codec.struct({ projects: Projects, lastProject: LastProject }, { preserve: true })
+
+// Projects and last-opened entries recorded under the canonical local server's URL move under
+// "local" when that URL is known, so they survive the server changing address.
 export function serverState(canonicalLocalServer: () => string | undefined = () => undefined) {
-  return Persistence.migrate(
+  return Codec.migrate(
    State,
-    Schema.Struct({ projects: Projects, lastProject: LastProject }).pipe(
-      Schema.decode({
-        decode: SchemaGetter.transform((value) => {
-          const canonical = canonicalLocalServer()
-          if (!canonical || canonical === "local") return value
-          const previous = value.projects[canonical]
-          const last = value.lastProject[canonical]
-          if (!previous && last === undefined) return value
+    Codec.transform(StoredState, {
+      decode: (value) => {
+        const canonical = canonicalLocalServer()
+        if (!canonical || canonical === "local") return value
+        const previous = value.projects[canonical]
+        const last = value.lastProject[canonical]
+        if (!previous && last === undefined) return value

-          const projects = { ...value.projects }
-          if (previous) {
-            const local = projects.local ?? []
-            const worktrees = new Set(local.map((project) => project.worktree))
-            projects.local = [
-              ...local,
-              ...previous.filter((project) => {
-                if (worktrees.has(project.worktree)) return false
-                worktrees.add(project.worktree)
-                return true
-              }),
-            ]
-            delete projects[canonical]
-          }
-          const lastProject = { ...value.lastProject }
-          if (last !== undefined) {
-            lastProject.local ??= last
-            delete lastProject[canonical]
-          }
-          return { ...value, projects, lastProject }
-        }),
-        encode: SchemaGetter.transform((value) => value),
-      }),
-    ),
+        const projects = { ...value.projects }
+        if (previous) {
+          const local = projects.local ?? []
+          const worktrees = new Set(local.map((project) => project.worktree))
+          projects.local = [
+            ...local,
+            ...previous.filter((project) => {
+              if (worktrees.has(project.worktree)) return false
+              worktrees.add(project.worktree)
+              return true
+            }),
+          ]
+          delete projects[canonical]
+        }
+        const lastProject = { ...value.lastProject }
+        if (last !== undefined) {
+          lastProject.local ??= last
+          delete lastProject[canonical]
+        }
+        return { ...value, projects, lastProject }
+      },
+      encode: (value) => value,
+    }),
  )
 }

-export const ModelState = Persistence.struct({
-  user: Persistence.array(
-    Persistence.struct({
-      providerID: Schema.String,
-      modelID: Schema.String,
-      visibility: Schema.Literals(["show", "hide"]),
-      favorite: Schema.optional(Schema.Boolean),
+export const ModelState = Codec.struct({
+  user: Codec.lenientArray(
+    Codec.struct({
+      providerID: Codec.string,
+      modelID: Codec.string,
+      visibility: Codec.literals(["show", "hide"]),
+      favorite: Codec.optional(Codec.boolean),
    }),
  ),
-  recent: Persistence.array(Persistence.struct({ providerID: Schema.String, modelID: Schema.String })),
-  variant: Schema.Record(
-    Schema.String,
-    Schema.mutableKey(
-      Schema.UndefinedOr(Schema.String).pipe(Schema.catchDecoding(() => Effect.succeed(Option.none()))),
-    ),
-  ),
+  recent: Codec.lenientArray(Codec.struct({ providerID: Codec.string, modelID: Codec.string })),
+  variant: Codec.sparseRecord(Codec.undefinedOr(Codec.string)),
 })

-export const VcsState = Persistence.struct({
-  value: Schema.optional(
-    Persistence.struct({
-      branch: Schema.optional(Schema.String),
-      default_branch: Schema.optional(Schema.String),
+export const VcsState = Codec.struct({
+  value: Codec.optional(
+    Codec.struct({
+      branch: Codec.optional(Codec.string),
+      default_branch: Codec.optional(Codec.string),
    }),
  ),
 })

-const ProjectMeta = Persistence.struct({
-  name: Schema.optional(Schema.String),
-  icon: Schema.optional(
-    Persistence.struct({
-      override: Schema.optional(Schema.String),
-      color: Schema.optional(Schema.String),
+const ProjectMeta = Codec.struct({
+  name: Codec.optional(Codec.string),
+  icon: Codec.optional(
+    Codec.struct({
+      override: Codec.optional(Codec.string),
+      color: Codec.optional(Codec.string),
    }),
  ),
-  commands: Schema.optional(Persistence.struct({ start: Schema.optional(Schema.String) })),
+  commands: Codec.optional(Codec.struct({ start: Codec.optional(Codec.string) })),
 })

-export const ProjectState = Persistence.struct({
-  value: Schema.optional(ProjectMeta),
+export const ProjectState = Codec.struct({
+  value: Codec.optional(ProjectMeta),
 })

-export const IconState = Persistence.struct({
-  value: Schema.optional(Schema.String),
+export const IconState = Codec.struct({
+  value: Codec.optional(Codec.string),
 })
+
@@ -1,13 +1,12 @@
 import { describe, expect, test } from "bun:test"
 import { canRemoveServer, createServerProjects, resolveServerList, ServerConnection } from "./registry"
-import { Schema } from "effect"
 import { serverState } from "./persistence"
 import { createStore } from "solid-js/store"
 import { ServerScope } from "./scope"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"

 function serverSchema() {
-  return Persistence.withInitial(serverState(), {
+  return Codec.withInitial(serverState(), {
    list: [],
    hidden: {},
    projects: {},
@@ -19,7 +18,7 @@ function serverSchema() {
 describe("resolveServerList", () => {
  test("lets startup auth_token credentials override a persisted same-url server", () => {
    const list = resolveServerList({
-      stored: Schema.decodeUnknownSync(serverSchema())({ list: [{ url: "https://server.example.test" }] }).list,
+      stored: Codec.decodeOrThrow(serverSchema(), { list: [{ url: "https://server.example.test" }] }).list,
      props: [
        {
          type: "http",
@@ -44,7 +43,7 @@ describe("resolveServerList", () => {

  test("keeps persisted credentials when startup has no auth_token", () => {
    const list = resolveServerList({
-      stored: Schema.decodeUnknownSync(serverSchema())({
+      stored: Codec.decodeOrThrow(serverSchema(), {
        list: [{ url: "https://server.example.test", password: "saved" }],
      }).list,
      props: [{ type: "http", http: { url: "https://server.example.test" } }],
@@ -77,7 +76,7 @@ test("treats WSL sidecars as remote server connections", () => {
 })

 test("keeps exact persisted server identities and prevents removing provided servers", () => {
-  const stored = Schema.decodeUnknownSync(serverSchema())({
+  const stored = Codec.decodeOrThrow(serverSchema(), {
    list: ["http://localhost:4096", "http://localhost:4096/", "http://127.0.0.1:4096"],
  }).list
  expect(resolveServerList({ stored }).map((server) => String(ServerConnection.key(server)))).toEqual([
@@ -91,7 +90,7 @@ test("keeps exact persisted server identities and prevents removing provided ser
 })

 test("project actions update schema-derived state and follow dynamic server scopes", () => {
-  const [store, setStore] = createStore(Schema.decodeUnknownSync(serverSchema())({}))
+  const [store, setStore] = createStore(Codec.decodeOrThrow(serverSchema(), {}))
  const props: { server: ServerConnection.Key; canonicalLocalServer?: ServerConnection.Key } = {
    server: ServerConnection.Key.make("https://remote.example"),
  }
@@ -115,3 +114,4 @@ test("project actions update schema-derived state and follow dynamic server scop
  expect(store.projects.local).toEqual([{ worktree: "/local", expanded: true }])
  expect(store.projects[props.server]).toEqual([{ worktree: "/remote", expanded: false }])
 })
+
@@ -1,12 +1,12 @@
-import { Option, Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import { normalizeServerUrl } from "@/runtime/server/registry"

-const pairing = Schema.fromJsonString(
-  Schema.Struct({
-    urls: Schema.Array(Schema.String),
-    username: Schema.Literal("opencode"),
-    password: Schema.String,
-  }),
+const pairing = Codec.fromJsonString(
+  Codec.struct({
+    urls: Codec.array(Codec.string),
+    username: Codec.literal("opencode"),
+    password: Codec.string,
+  }),
 )

 export function serverAddress(value: string) {
@@ -20,9 +20,10 @@ export function serverAddress(value: string) {
 }

 export function decodePairingCode(value: string) {
-  const result = Schema.decodeUnknownOption(pairing)(value)
-  if (Option.isNone(result)) return
-  const urls = [...new Set(result.value.urls.map(serverAddress).filter((url) => url !== undefined))]
-  if (!urls.length) return
-  return { urls, password: result.value.password }
+  const result = Codec.decodeOption(pairing, value)
+  if (!result) return
+  const urls = [...new Set(result.urls.map(serverAddress).filter((url) => url !== undefined))]
+  if (!urls.length) return
+  return { urls, password: result.password }
 }
+
@@ -20,18 +20,13 @@ 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
@@ -48,7 +43,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 || !address(),
+      disabled: !props.visible || !state(),
      onSelect: () => {
        const tab = state()
        if (tab) props.browser.command({ type: "reload", tabID: tab.id })
@@ -76,9 +71,7 @@ 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)
-    // 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)
+    const visible = props.visible && store.visible && !dialog.active && !covered(rect)
    // The cutout exposes the app backdrop outside the rounded Review card,
    // not the browser surface inside it.
    const color = getComputedStyle(
@@ -114,25 +107,7 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
    if (frame === undefined) frame = requestAnimationFrame(tick)
  }

-  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(() => !store.editing && setStore("address", address()))
  createEffect(
    on(registration, (current) => {
      // Session routes can change before this pane unmounts. Hide the registration
@@ -148,8 +123,6 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
        () => store.visible,
        () => props.visible,
        () => state()?.id,
-        empty,
-        failed,
        registration,
      ],
      () => {
@@ -184,7 +157,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-3 border-b border-v2-border-border-muted">
+      <div class="h-10 shrink-0 flex items-center gap-1 px-2 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")}>
@@ -220,7 +193,7 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
        >
          <IconButton
            {...button}
-            disabled={!state()?.loading && !address()}
+            disabled={!state()}
            aria-label={language.t(state()?.loading ? "prompt.action.stop" : "error.page.action.reload")}
            onClick={() => {
              const tab = state()
@@ -239,13 +212,8 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
          onSubmit={(event) => {
            event.preventDefault()
            const tab = state()
-            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()
+            if (tab && store.address.trim())
+              props.browser.command({ type: "navigate", tabID: tab.id, url: store.address })
          }}
        >
          <input
@@ -256,14 +224,8 @@ 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={(event) => {
-              setStore("editing", true)
-              event.currentTarget.select()
-            }}
-            onClick={(event) => event.currentTarget.select()}
-            onBlur={() =>
-              setStore({ editing: false, address: store.submitted ? store.address : address(), submitted: false })
-            }
+            onFocus={() => setStore("editing", true)}
+            onBlur={() => setStore({ editing: false, address: address() })}
            onInput={(event) => setStore("address", event.currentTarget.value)}
            onScroll={(event) => {
              if (addressDisplay) addressDisplay.scrollLeft = event.currentTarget.scrollLeft
@@ -281,27 +243,12 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
          </div>
        </form>
      </div>
-      <Show when={props.browser.error() && !failed()}>
+      <Show when={props.browser.error()}>
        <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")}
@@ -1,9 +1,8 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
 import { OPEN_APPS, OpenAppPreferences } from "./open-in-app"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"

-const decode = Schema.decodeUnknownSync(Persistence.withInitial(OpenAppPreferences, { app: "finder" }))
+const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(OpenAppPreferences, { app: "finder" }), input))

 describe("open app preferences", () => {
  test.each([...OPEN_APPS])("preserves the %s preference", (app) => {
@@ -18,3 +17,4 @@ describe("open app preferences", () => {
    expect(decode({})).toEqual({ app: "finder" })
  })
 })
+
@@ -5,8 +5,7 @@ import { usePlatform } from "@/runtime/platform/platform"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { showToast } from "@/shell/notifications/toast"
 import { useServer } from "@/runtime/server/current"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { fileManagerApp } from "@/home/projects/file-manager"
 import { openInAppParentPath } from "@/session/files/open-in-app-path"

@@ -30,8 +29,8 @@ export const OPEN_APPS = [
 export type OpenApp = (typeof OPEN_APPS)[number]
 export type OpenAppOS = "macos" | "windows" | "linux" | "unknown"

-export const OpenAppPreferences = Persistence.struct({
-  app: Schema.Literals(OPEN_APPS),
+export const OpenAppPreferences = Codec.struct({
+  app: Codec.literals(OPEN_APPS),
 })

 const appExistence = new Map<string, Promise<boolean>>()
@@ -242,3 +241,4 @@ function checkAppExists(platform: ReturnType<typeof usePlatform>, app: string) {
  appExistence.set(app, request)
  return request
 }
+
@@ -1,8 +1,6 @@
 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"
@@ -71,19 +69,9 @@ export function SortableTab(props: {
              placement="bottom"
              gutter={10}
            >
-              <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" />}
+              <Tabs.CloseButton
+                class="h-5 w-5"
+                onClick={() => props.onTabClose(props.tab)}
                aria-label={language.t("common.closeTab")}
              />
            </Tooltip>
@@ -5,17 +5,20 @@ import {
  type SessionReviewExpandMode,
 } from "@opencode/session-ui/v2/session-review-v2"
 import { createSignal } from "solid-js"
-import { Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import type { Platform } from "@/runtime/platform/platform"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"

-const ReviewPanel = Persistence.struct({
-  sidebarOpened: Schema.Boolean,
-  sidebarWidth: Schema.Finite.check(
-    Schema.isBetween({ minimum: SESSION_REVIEW_V2_SIDEBAR_WIDTH_MIN, maximum: SESSION_REVIEW_V2_SIDEBAR_WIDTH_MAX }),
-  ),
-  expandMode: Schema.Literals(["expand", "collapse"]),
+const ReviewPanel = Codec.struct({
+  sidebarOpened: Codec.boolean,
+  sidebarWidth: Codec.make<number, number>(
+    (v) =>
+      typeof v === "number" && v >= SESSION_REVIEW_V2_SIDEBAR_WIDTH_MIN && v <= SESSION_REVIEW_V2_SIDEBAR_WIDTH_MAX
+        ? v
+        : Codec.INVALID,
+    (v) => v,
+  ),
+  expandMode: Codec.literals(["expand", "collapse"]),
 })

 export function createReviewPanelState(platform?: Platform) {
@@ -47,3 +50,4 @@ export function createReviewPanelState(platform?: Platform) {
 }

 export type ReviewPanelState = ReturnType<typeof createReviewPanelState>
+
@@ -2,9 +2,8 @@ import { beforeAll, describe, expect, mock, test } from "bun:test"
 import { ServerScope } from "@/runtime/server/scope"
 import { base64Encode } from "@opencode/util/encode"
 import { Persist } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import type { Platform } from "@/runtime/platform/platform"
-import { Schema } from "effect"

 let getWorkspaceTerminalCacheKey: typeof import("./context").getWorkspaceTerminalCacheKey
 let clearWorkspaceTerminals: typeof import("./context").clearWorkspaceTerminals
@@ -21,10 +20,10 @@ beforeAll(async () => {
  const mod = await import("./context")
  getWorkspaceTerminalCacheKey = mod.getWorkspaceTerminalCacheKey
  clearWorkspaceTerminals = mod.clearWorkspaceTerminals
-  const schema = Persistence.withInitial(mod.TerminalState, { all: [] })
-  decodeTerminalState = Schema.decodeUnknownSync(schema)
+  const schema = Codec.withInitial(mod.TerminalState, { all: [] })
+  decodeTerminalState = ((input: unknown) => Codec.decodeOrThrow(schema, input))
  roundTripTerminalState = (value) =>
-    Schema.decodeUnknownSync(schema)(Schema.encodeSync(schema)(Schema.decodeUnknownSync(schema)(value)))
+    Codec.decodeOrThrow(schema, schema.encode(Codec.decodeOrThrow(schema, value)))
 })

 describe("getWorkspaceTerminalCacheKey", () => {
@@ -141,3 +140,4 @@ describe("TerminalState", () => {
    expect(roundTripTerminalState(value)).toEqual(value)
  })
 })
+
@@ -8,18 +8,20 @@ import { base64Encode } from "@opencode/util/encode"
 import { defaultTitle, titleNumber } from "./title"
 import { Persist, persisted, removePersisted } from "@/runtime/persistence/storage"
 import { ScopedKey, ServerScope } from "@/runtime/server/scope"
-import { Persistence } from "@/runtime/persistence/schema"
-import { Schema, SchemaGetter } from "effect"
+import { Codec } from "@/runtime/persistence/codec"

-const PTY = Persistence.struct({
-  id: Schema.NonEmptyString,
-  title: Persistence.fallback(Schema.String, () => ""),
-  titleNumber: Persistence.fallback(Schema.Finite, () => 0),
-  rows: Persistence.optional(Schema.Finite),
-  cols: Persistence.optional(Schema.Finite),
-  buffer: Persistence.optional(Schema.String),
-  scrollY: Persistence.optional(Schema.Finite),
-  cursor: Persistence.optional(Schema.Finite),
+const PTY = Codec.struct({
+  id: Codec.make<string, string>(
+    (v) => (typeof v === "string" && v.length > 0 ? v : Codec.INVALID),
+    (v) => v,
+  ),
+  title: Codec.fallback(Codec.string, () => ""),
+  titleNumber: Codec.fallback(Codec.number, () => 0),
+  rows: Codec.lenientOptional(Codec.number),
+  cols: Codec.lenientOptional(Codec.number),
+  buffer: Codec.lenientOptional(Codec.string),
+  scrollY: Codec.lenientOptional(Codec.number),
+  cursor: Codec.lenientOptional(Codec.number),
 })

 export type LocalPTY = typeof PTY.Type
@@ -31,28 +33,26 @@ function numberFromTitle(title: string) {
  return titleNumber(title, MAX_TERMINAL_SESSIONS)
 }

-const State = Persistence.struct({
-  active: Persistence.optional(Schema.String),
-  all: Persistence.array(PTY),
+const State = Codec.struct({
+  active: Codec.lenientOptional(Codec.string),
+  all: Codec.lenientArray(PTY),
 })

-export const TerminalState = State.pipe(
-  Schema.decodeTo(Schema.toType(State), {
-    decode: SchemaGetter.transform((value) => {
-      const seen = new Set<string>()
-      const all = value.all.flatMap((pty) => {
-        if (seen.has(pty.id)) return []
-        seen.add(pty.id)
-        return [{ ...pty, titleNumber: pty.titleNumber > 0 ? pty.titleNumber : (numberFromTitle(pty.title) ?? 0) }]
-      })
-      return {
-        active: value.active && seen.has(value.active) ? value.active : all[0]?.id,
-        all,
-      }
-    }),
-    encode: SchemaGetter.transform((value) => value),
-  }),
-)
+export const TerminalState = Codec.transform(State, {
+  decode: (value): typeof State.Type => {
+    const seen = new Set<string>()
+    const all = value.all.flatMap((pty) => {
+      if (seen.has(pty.id)) return []
+      seen.add(pty.id)
+      return [{ ...pty, titleNumber: pty.titleNumber > 0 ? pty.titleNumber : (numberFromTitle(pty.title) ?? 0) }]
+    })
+    return {
+      active: value.active && seen.has(value.active) ? value.active : all[0]?.id,
+      all,
+    }
+  },
+  encode: (value) => value,
+})

 export function getWorkspaceTerminalCacheKey(dir: string, scope: ServerScope = ServerScope.local) {
  return ScopedKey.from(scope, dir, WORKSPACE_KEY)
@@ -458,3 +458,5 @@ export const { use: useTerminal, provider: TerminalProvider } = createSimpleCont
    }
  },
 })
+
+
@@ -1,40 +1,40 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { GoUpsellState } from "./usage-exceeded-dialogs"
-import { Persistence } from "@/runtime/persistence/schema"
-
-const decode = Schema.decodeUnknownSync(
-  Persistence.withInitial(GoUpsellState, {
-    go_upsell_last_seen_at: null,
-    go_upsell_dont_show: null,
-    go_upsell_account_rate_limit_last_seen_at: null,
-    go_upsell_account_rate_limit_dont_show: null,
-  }),
-)
-
-describe("usage exceeded preferences", () => {
-  test("defaults unseen prompts", () => {
-    expect(decode({})).toEqual({
-      go_upsell_last_seen_at: null,
-      go_upsell_dont_show: null,
-      go_upsell_account_rate_limit_last_seen_at: null,
-      go_upsell_account_rate_limit_dont_show: null,
-    })
-  })
-
-  test("preserves timestamps while recovering malformed siblings", () => {
-    expect(
-      decode({
-        go_upsell_last_seen_at: 123,
-        go_upsell_dont_show: "true",
-        go_upsell_account_rate_limit_last_seen_at: Infinity,
-        go_upsell_account_rate_limit_dont_show: 456,
-      }),
-    ).toEqual({
-      go_upsell_last_seen_at: 123,
-      go_upsell_dont_show: null,
-      go_upsell_account_rate_limit_last_seen_at: null,
-      go_upsell_account_rate_limit_dont_show: 456,
-    })
-  })
-})
+import { describe, expect, test } from "bun:test"
+import { GoUpsellState } from "./usage-exceeded-dialogs"
+import { Codec } from "@/runtime/persistence/codec"
+
+const schema = Codec.withInitial(GoUpsellState, {
+  go_upsell_last_seen_at: null,
+  go_upsell_dont_show: null,
+  go_upsell_account_rate_limit_last_seen_at: null,
+  go_upsell_account_rate_limit_dont_show: null,
+})
+const decode = (input: unknown) => Codec.decodeOrThrow(schema, input)
+
+describe("usage exceeded preferences", () => {
+  test("defaults unseen prompts", () => {
+    expect(decode({})).toEqual({
+      go_upsell_last_seen_at: null,
+      go_upsell_dont_show: null,
+      go_upsell_account_rate_limit_last_seen_at: null,
+      go_upsell_account_rate_limit_dont_show: null,
+    })
+  })
+
+  test("preserves timestamps while recovering malformed siblings", () => {
+    expect(
+      decode({
+        go_upsell_last_seen_at: 123,
+        go_upsell_dont_show: "true",
+        go_upsell_account_rate_limit_last_seen_at: Infinity,
+        go_upsell_account_rate_limit_dont_show: 456,
+      }),
+    ).toEqual({
+      go_upsell_last_seen_at: 123,
+      go_upsell_dont_show: null,
+      go_upsell_account_rate_limit_last_seen_at: null,
+      go_upsell_account_rate_limit_dont_show: 456,
+    })
+  })
+})
+
+
@@ -2,8 +2,7 @@ import { useWorkspaceLocation } from "@/workspaces/location"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import type { SessionStatus } from "@opencode/client/promise"
 import { onCleanup } from "solid-js"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { useSessionLayout } from "./session-layout"
 import { useDialog, useI18n } from "@opencode/ui/context"
 import { DialogUsageExceeded } from "@/providers/connect/usage-exceeded"
@@ -15,11 +14,11 @@ const GO_UPSELL_ACCOUNT_RATE_LIMIT_DONT_SHOW = "go_upsell_account_rate_limit_don
 const GO_UPSELL_WINDOW = 86_400_000 // 24 hrs
 const GO_UPSELL_PROVIDERS = new Set(["opencode", "opencode-go"])

-export const GoUpsellState = Persistence.struct({
-  [GO_UPSELL_FREE_TIER_LAST_SEEN_AT]: Schema.NullOr(Schema.Finite),
-  [GO_UPSELL_FREE_TIER_DONT_SHOW]: Schema.NullOr(Schema.Finite),
-  [GO_UPSELL_ACCOUNT_RATE_LIMIT_LAST_SEEN_AT]: Schema.NullOr(Schema.Finite),
-  [GO_UPSELL_ACCOUNT_RATE_LIMIT_DONT_SHOW]: Schema.NullOr(Schema.Finite),
+export const GoUpsellState = Codec.struct({
+  [GO_UPSELL_FREE_TIER_LAST_SEEN_AT]: Codec.nullOr(Codec.number),
+  [GO_UPSELL_FREE_TIER_DONT_SHOW]: Codec.nullOr(Codec.number),
+  [GO_UPSELL_ACCOUNT_RATE_LIMIT_LAST_SEEN_AT]: Codec.nullOr(Codec.number),
+  [GO_UPSELL_ACCOUNT_RATE_LIMIT_DONT_SHOW]: Codec.nullOr(Codec.number),
 })

 function goUpsellKeys(status: SessionStatus) {
@@ -106,3 +105,4 @@ export function useUsageExceededDialogs() {
    }),
  )
 }
+
@@ -1,7 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
 import { timelinePresets } from "@opencode/session-ui/timeline/detail"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import {
  settingsSchema,
  settingsPersistence,
@@ -13,9 +12,9 @@ import {
  terminalFontFamily,
 } from "./model"

-const schema = Persistence.withInitial(settingsPersistence, defaultSettings)
-const decode = Schema.decodeUnknownSync(schema)
-const encode = Schema.encodeSync(schema)
+const schema = Codec.withInitial(settingsPersistence, defaultSettings)
+const decode = (input: unknown) => Codec.decodeOrThrow(schema, input)
+const encode = (value: typeof settingsSchema.Type) => schema.encode(value)

 describe("settings timeline detail migration", () => {
  test("migrates saved switches and round trips the current settings", () => {
@@ -51,14 +50,14 @@ describe("settings schema", () => {
      general: { ...defaultSettings.general, timelineDetail: timelinePresets[4].value, autoSave: false },
      appearance: { ...defaultSettings.appearance, fontSize: 20 },
    }
-    const restore = Schema.decodeUnknownSync(Persistence.withInitial(settingsPersistence, initial))
+    const restore = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(settingsPersistence, initial), input)
    expect(restore({})).toEqual(initial)
    expect(restore({ general: { reasoningMode: "invalid", showReasoningSummaries: true } })).toEqual(initial)
    expect(restore({ general: { showReasoningSummaries: true } }).general.timelineDetail.thinking).toEqual({
      placement: "separate",
      details: "expanded",
    })
-    expect(() => Schema.decodeUnknownSync(settingsSchema)({})).toThrow()
+    expect(() => Codec.decodeOrThrow(settingsSchema, {})).toThrow()
  })

  test("supplies the existing defaults for an empty document", () => {
@@ -171,7 +170,7 @@ describe("settings schema", () => {

  test("does not silently repair invalid values during encoding", () => {
    expect(() =>
-      Schema.encodeUnknownSync(settingsSchema)({ ...decode({}), appearance: { fontSize: "large" } }),
+      Codec.encodeOrThrow(settingsSchema, { ...decode({}), appearance: { fontSize: "large" } } as never),
    ).toThrow()
  })
 })
@@ -203,3 +202,6 @@ describe("settings font families", () => {
    expect(terminalFontFamily(undefined)).toStartWith('"JetBrainsMono Nerd Font Mono", ')
  })
 })
+
+
+
@@ -5,8 +5,7 @@ import { Icon } from "@opencode/ui/icon"
 import { IconButton } from "@opencode/ui/icon-button"
 import { TextInput } from "@opencode/ui/text-input"
 import { type Component, createEffect, For, on, onCleanup, Show } from "solid-js"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useModels } from "@/providers/models/models"
 import { useServerSDK } from "@/runtime/server/client"
@@ -20,8 +19,8 @@ type ModelItem = ReturnType<ReturnType<typeof useModels>["list"]>[number]

 const PROVIDER_ICON_SIZE = 16

-export const ModelProvidersSchema = Schema.Struct({
-  collapsed: Persistence.record(Persistence.fallback(Schema.Boolean, () => false)),
+export const ModelProvidersSchema = Codec.struct({
+  collapsed: Codec.lenientRecord(Codec.fallback(Codec.boolean, () => false)),
 })

 export const SettingsModels: Component<{ active?: boolean; autofocus?: boolean }> = (props) => {
@@ -211,3 +210,4 @@ export const SettingsModels: Component<{ active?: boolean; autofocus?: boolean }
    </>
  )
 }
+
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import {
  activeCommandRegistrations,
  addCommandRegistration,
@@ -10,12 +10,12 @@ import {
 } from "./command"

 test("command catalog persistence validates metadata and omits executable fields", () => {
-  const decode = Schema.decodeUnknownSync(CommandCatalog)
+  const decode = ((input: unknown) => Codec.decodeOrThrow(CommandCatalog, input))
  const catalog = decode({ open: { title: "Open", keybind: "mod+o", hidden: false, onSelect: "invalid" } })
  expect(catalog).toEqual({ open: { title: "Open", keybind: "mod+o", hidden: false } })
  expect(decode({})).toEqual({})
  expect(() => decode({ open: { title: 1 } })).toThrow()
-  expect(decode(Schema.encodeSync(CommandCatalog)(catalog))).toEqual(catalog)
+  expect(decode(CommandCatalog.encode(catalog))).toEqual(catalog)
 })

 const paletteOptions: CommandOption[] = [
@@ -79,3 +79,4 @@ describe("resolveKeybindOption", () => {
    expect(resolveKeybindOption([fallback, contextual], new KeyboardEvent("keydown"))).toBe(fallback)
  })
 })
+
@@ -2,8 +2,8 @@ import { createSimpleContext } from "@opencode/ui/context"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { type Accessor, batch, createEffect, createMemo, onCleanup, onMount } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
+
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useSettings } from "@/settings/model"
@@ -109,16 +109,16 @@ export function resolveKeybindOption(candidates: CommandOption[] | undefined, ev

 type CommandSource = "palette" | "keybind" | "slash"

-export const CommandCatalogItem = Persistence.struct({
-  title: Schema.String,
-  description: Schema.optional(Schema.String),
-  category: Schema.optional(Schema.String),
-  keybind: Schema.optional(Schema.String),
-  slash: Schema.optional(Schema.String),
-  hidden: Schema.optional(Schema.Boolean),
+export const CommandCatalogItem = Codec.struct({
+  title: Codec.string,
+  description: Codec.optional(Codec.string),
+  category: Codec.optional(Codec.string),
+  keybind: Codec.optional(Codec.string),
+  slash: Codec.optional(Codec.string),
+  hidden: Codec.optional(Codec.boolean),
 })
 export type CommandCatalogItem = typeof CommandCatalogItem.Type
-export const CommandCatalog = Schema.Record(Schema.String, Schema.mutableKey(CommandCatalogItem))
+export const CommandCatalog = Codec.record(CommandCatalogItem)
 export type CommandCatalog = typeof CommandCatalog.Type

 export type CommandRegistration = {
@@ -480,3 +480,4 @@ export const { use: useCommand, provider: CommandProvider } = createSimpleContex
    }
  },
 })
+
@@ -1,23 +1,22 @@
 import { expect, test } from "bun:test"
-import { Schema } from "effect"
 import type { ServerConnection } from "@/runtime/server/registry"
 import type { Tab } from "@/shell/tabs/tabs"
 import { NotificationStore, openNotificationSession, type Notification } from "./notification"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"

 test("notification persistence validates and salvages individual notifications", () => {
  const valid: Notification[] = [
    { type: "turn-complete", time: 123, viewed: false, session: "session-1" },
    { type: "error", time: 124, viewed: true, error: { type: "api", message: "failed", status: 500 } },
  ]
-  const decode = Schema.decodeUnknownSync(Persistence.withInitial(NotificationStore, { list: [] }))
+  const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(NotificationStore, { list: [] }), input))
  const store = decode({
    list: [valid[0], null, { type: "unknown", time: 123, viewed: false }, { ...valid[1], error: "invalid" }, valid[1]],
  })
  expect(store.list).toEqual(valid)
  expect(decode({})).toEqual({ list: [] })
  expect(decode({ list: {} })).toEqual({ list: [] })
-  expect(decode(Schema.encodeSync(NotificationStore)(store))).toEqual(store)
+  expect(decode(NotificationStore.encode(store))).toEqual(store)
 })

 test("opens notification sessions through the tab router", () => {
@@ -41,3 +40,4 @@ test("opens notification sessions through the tab router", () => {

  expect(calls).toEqual(["add:session-1", "route:session-1", "select:session-1"])
 })
+
@@ -1,6 +1,6 @@
 import { createStore, reconcile } from "solid-js/store"
-import { Schema } from "effect"
-import { SessionError } from "@opencode/schema/session-error"
+import { Codec } from "@/runtime/persistence/codec"
+import type { SessionError } from "@opencode/schema/session-error"
 import { type Accessor, batch, createEffect, createMemo, createRoot, getOwner, onCleanup } from "solid-js"
 import { createSimpleContext } from "@opencode/ui/context"
 import type { ServerSDK } from "@/runtime/server/client"
@@ -10,7 +10,7 @@ import { useLanguage } from "@/runtime/i18n/language"
 import { useSettings } from "@/settings/model"
 import { decode64 } from "@/runtime/persistence/base64"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
+
 import { playSoundById } from "@/shell/notifications/sound"
 import type { createNotificationCoordinator } from "@/shell/notifications/coordinator"
 import { useGlobal } from "@/runtime/server/runtime"
@@ -20,19 +20,28 @@ import { requireServerKey, sessionHref } from "@/shell/routes/session"
 import type { ServerScope } from "@/runtime/server/scope"
 import { useServer } from "@/runtime/server/current"

-const NotificationBase = {
-  directory: Schema.optional(Schema.String),
-  session: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Unknown),
-  time: Schema.Finite,
-  viewed: Schema.Boolean,
-}
-export const Notification = Schema.Union([
-  Persistence.struct({ ...NotificationBase, type: Schema.Literal("turn-complete") }),
-  Persistence.struct({ ...NotificationBase, type: Schema.Literal("error"), error: SessionError.Error }),
+const NotificationBase = {
+  directory: Codec.optional(Codec.string),
+  session: Codec.optional(Codec.string),
+  metadata: Codec.optional(Codec.unknown),
+  time: Codec.number,
+  viewed: Codec.boolean,
+}
+// The error payload is whatever the server reported; shape-checking it here would load the shared
+// Effect schema into the renderer's startup path for a value the server already validated.
+const StoredSessionError = Codec.make<SessionError.Error, unknown>(
+  (value) =>
+    typeof value === "object" && value !== null && "name" in value && "message" in value
+      ? (value as unknown as SessionError.Error)
+      : Codec.INVALID,
+  (value) => value,
+)
+export const Notification = Codec.union([
+  Codec.struct({ ...NotificationBase, type: Codec.literal("turn-complete") }),
+  Codec.struct({ ...NotificationBase, type: Codec.literal("error"), error: StoredSessionError }),
 ])
 export type Notification = typeof Notification.Type
-export const NotificationStore = Persistence.struct({ list: Persistence.array(Notification) })
+export const NotificationStore = Codec.struct({ list: Codec.lenientArray(Notification) })

 type NotificationIndex = {
  session: {
@@ -368,3 +377,5 @@ export const useNotification = () => {
  const server = useServer()
  return server.ctx.notification
 }
+
+
@@ -1,8 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import { createRoot, createSignal } from "solid-js"
-import { Schema } from "effect"
 import { ServerConnection } from "@/runtime/server/registry"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
 import { currentRoute, initialLayout, layoutPersistence, layoutSchema } from "./layout"
 import { createSessionKeyReader, ensureSessionKey, pruneSessionKeys } from "./helpers"

@@ -11,21 +10,21 @@ test("settings has its own layout route", () => {
 })

 describe("layout persistence", () => {
-  const schema = Persistence.withInitial(layoutPersistence, initialLayout(ServerConnection.Key.make("local")))
-  const decode = Schema.decodeUnknownSync(schema)
+  const schema = Codec.withInitial(layoutPersistence, initialLayout(ServerConnection.Key.make("local")))
+  const decode = (input: unknown) => Codec.decodeOrThrow(schema, input)

  test("uses supplied initial preferences after legacy migration", () => {
    const initial = initialLayout(ServerConnection.Key.make("remote"))
    initial.sidebar.width = 420
    initial.fileTree.width = 300
    initial.review.panelOpened = true
-    const restore = Schema.decodeUnknownSync(Persistence.withInitial(layoutPersistence, initial))
+    const restore = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(layoutPersistence, initial), input)
    expect(restore({})).toEqual(initial)
    expect(restore({ sidebar: { width: "bad" } }).sidebar.width).toBe(420)
    expect(restore({ fileTree: { width: 260 } }).fileTree.width).toBe(200)
    expect(restore({ fileTree: {} }).fileTree.width).toBe(300)
    expect(restore({ review: {}, fileTree: { opened: false } }).review.panelOpened).toBe(false)
-    expect(() => Schema.decodeUnknownSync(layoutSchema)({})).toThrow()
+    expect(() => Codec.decodeOrThrow(layoutSchema, {})).toThrow()
  })

  test("restores shipped defaults for missing and invalid fields", () => {
@@ -56,8 +55,8 @@ describe("layout persistence", () => {
    expect(value.sidebar).toEqual({ opened: false, width: 344, workspaces: {}, workspacesDefault: true })
    expect(value.review).toEqual({ diffStyle: "split", panelOpened: true })
    expect(value.fileTree).toEqual({ opened: true, width: 200, tab: "changes" })
-    expect(Schema.encodeSync(schema)(value)).toEqual(value)
-    expect(decode(Schema.encodeSync(schema)(value))).toEqual(value)
+    expect(schema.encode(value)).toEqual(value)
+    expect(decode(schema.encode(value))).toEqual(value)
    expect(decode({ fileTree: { opened: true } }).review.panelOpened).toBe(false)
  })

@@ -169,3 +168,4 @@ describe("pruneSessionKeys", () => {
    expect(drop).toEqual([])
  })
 })
+
@@ -1,63 +1,58 @@
 export * as TabStorage from "./schema"

-import { Schema, SchemaGetter } from "effect"
-import { ServerKey } from "@/runtime/server/persistence"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"
+import { ServerKey } from "@/runtime/server/key"

 export { ServerKey }

-export const Session = Persistence.struct({
-  type: Schema.Literal("session"),
+export const Session = Codec.struct({
+  type: Codec.literal("session"),
  server: ServerKey,
-  sessionId: Schema.String,
-  routeSessionId: Persistence.optional(Schema.String),
-  routeParentId: Persistence.optional(Schema.String),
+  sessionId: Codec.string,
+  routeSessionId: Codec.lenientOptional(Codec.string),
+  routeParentId: Codec.lenientOptional(Codec.string),
 })

-export const Draft = Persistence.struct({
-  type: Schema.Literal("draft"),
-  draftID: Schema.String,
+export const Draft = Codec.struct({
+  type: Codec.literal("draft"),
+  draftID: Codec.string,
  server: ServerKey,
-  directory: Schema.String,
-  worktree: Persistence.optional(Schema.String),
-  branch: Persistence.optional(Schema.String),
-  mcp: Persistence.optional(Persistence.struct({ target: Schema.String, states: Persistence.record(Schema.Boolean) })),
+  directory: Codec.string,
+  worktree: Codec.lenientOptional(Codec.string),
+  branch: Codec.lenientOptional(Codec.string),
+  mcp: Codec.lenientOptional(Codec.struct({ target: Codec.string, states: Codec.lenientRecord(Codec.boolean) })),
 })

-const SessionCodec = Session.pipe(
-  Schema.decodeTo(Schema.toType(Session), {
-    decode: SchemaGetter.transform((tab) => ({
-      type: tab.type,
-      server: tab.server,
-      sessionId: tab.sessionId,
-      ...(tab.routeSessionId && tab.routeSessionId !== tab.sessionId
-        ? { routeSessionId: tab.routeSessionId, ...(tab.routeParentId ? { routeParentId: tab.routeParentId } : {}) }
-        : {}),
-    })),
-    encode: SchemaGetter.transform((tab) => tab),
+// A stored route that only repeats the session id carries nothing; drop it and its parent.
+const SessionCodec = Codec.transform(Session, {
+  decode: (tab) => ({
+    type: tab.type,
+    server: tab.server,
+    sessionId: tab.sessionId,
+    ...(tab.routeSessionId && tab.routeSessionId !== tab.sessionId
+      ? { routeSessionId: tab.routeSessionId, ...(tab.routeParentId ? { routeParentId: tab.routeParentId } : {}) }
+      : {}),
+  }),
+  encode: (tab) => tab,
+})
+
+export const Tab = Codec.union([Session, Draft])
+export const Tabs = Codec.lenientArray(Codec.union([SessionCodec, Draft]))
+export const Recent = Codec.struct({
+  key: Codec.optional(Codec.string),
+})
+export const Info = Codec.struct({
+  title: Codec.optional(Codec.string),
+  directory: Codec.optional(Codec.string),
+})
+export const Infos = Codec.record(Info)
+export const Panes = Codec.record(
+  Codec.struct({
+    terminal: Codec.optional(Codec.boolean),
+    review: Codec.optional(Codec.boolean),
+    terminalHeight: Codec.optional(Codec.number),
+    sessionWidth: Codec.optional(Codec.number),
  }),
 )
-
-export const Tab = Schema.Union([Session, Draft])
-export const Tabs = Persistence.array(Schema.Union([SessionCodec, Draft]))
-export const Recent = Persistence.struct({
-  key: Schema.optional(Schema.String),
-})
-export const Info = Persistence.struct({
-  title: Schema.optional(Schema.String),
-  directory: Schema.optional(Schema.String),
-})
-export const Infos = Schema.Record(Schema.String, Schema.mutableKey(Info))
-export const Panes = Schema.Record(
-  Schema.String,
-  Schema.mutableKey(
-    Persistence.struct({
-      terminal: Schema.optional(Schema.Boolean),
-      review: Schema.optional(Schema.Boolean),
-      terminalHeight: Schema.optional(Schema.Finite),
-      sessionWidth: Schema.optional(Schema.Finite),
-    }),
-  ),
-)
-export const ClosedTab = Schema.Struct({ tab: SessionCodec, index: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) })
-export const Closed = Persistence.array(ClosedTab)
+export const ClosedTab = Codec.struct({ tab: SessionCodec, index: Codec.nonNegativeInt })
+export const Closed = Codec.lenientArray(ClosedTab)
@@ -3,13 +3,12 @@ import { createRoot, getOwner, onCleanup } from "solid-js"
 import { createTabMemory } from "./memory"
 import { nextTabAfterClose, pushClosedTab, removeClosedTabs, takeClosedTab, type ClosedTab } from "./closed"
 import { findSessionTab, sessionIDHasOpenTab, tabHref, tabKey, type SessionTab, type Tab } from "./tabs"
-import { Schema } from "effect"
 import { TabStorage } from "./schema"
 import type { ServerConnection } from "@/runtime/server/registry"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"

 const server = "local\nhttp://localhost:4096" as ServerConnection.Key
-const decodeTabs = Schema.decodeUnknownSync(Persistence.withInitial(TabStorage.Tabs, []))
+const decodeTabs = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(TabStorage.Tabs, []), input))

 function sessionTab(sessionId: string): SessionTab {
  return { type: "session", server, sessionId }
@@ -26,7 +25,7 @@ describe("tab migration", () => {
    }
    const restored = decodeTabs([legacy, draft])
    expect(restored).toEqual([legacy, draft])
-    expect(decodeTabs(Schema.encodeSync(TabStorage.Tabs)(restored))).toEqual([legacy, draft])
+    expect(decodeTabs(TabStorage.Tabs.encode(restored))).toEqual([legacy, draft])
  })

  test("drops null and malformed persisted tabs", () => {
@@ -64,13 +63,13 @@ describe("tab migration", () => {
      draft,
    ])
    expect(tabs).toEqual([sessionTab("root"), draft])
-    expect(Schema.encodeSync(TabStorage.Tabs)(tabs)).toEqual(tabs)
-    expect(decodeTabs(Schema.encodeSync(TabStorage.Tabs)(tabs))).toEqual(tabs)
+    expect(TabStorage.Tabs.encode(tabs)).toEqual(tabs)
+    expect(decodeTabs(TabStorage.Tabs.encode(tabs))).toEqual(tabs)
  })

  test("salvages valid closed session tabs", () => {
    expect(
-      Schema.decodeUnknownSync(Persistence.withInitial(TabStorage.Closed, []))([
+      ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(TabStorage.Closed, []), input))([
        { tab: sessionTab("a"), index: 1 },
        { tab: sessionTab("b"), index: -1 },
        { tab: { type: "draft", server, draftID: "d", directory: "/project" }, index: 0 },
@@ -81,16 +80,16 @@ describe("tab migration", () => {

  test("validates auxiliary tab state", () => {
    expect(
-      Schema.decodeUnknownSync(Persistence.withInitial(TabStorage.Recent, { key: undefined }))({ key: 1 }),
+      ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(TabStorage.Recent, { key: undefined }), input))({ key: 1 }),
    ).toEqual({ key: undefined })
-    expect(Schema.decodeUnknownSync(TabStorage.Infos)({})).toEqual({})
-    expect(Schema.decodeUnknownSync(TabStorage.Panes)({})).toEqual({})
-    expect(Schema.decodeUnknownSync(TabStorage.Infos)({ tab: { title: "Title", directory: "/project" } })).toEqual({
+    expect(Codec.decodeOrThrow(TabStorage.Infos, {})).toEqual({})
+    expect(Codec.decodeOrThrow(TabStorage.Panes, {})).toEqual({})
+    expect(Codec.decodeOrThrow(TabStorage.Infos, { tab: { title: "Title", directory: "/project" } })).toEqual({
      tab: { title: "Title", directory: "/project" },
    })
-    const panes = Schema.decodeUnknownSync(TabStorage.Panes)({ tab: { terminal: true, terminalHeight: 300 } })
-    expect(Schema.encodeSync(TabStorage.Panes)(panes)).toEqual({ tab: { terminal: true, terminalHeight: 300 } })
-    expect(() => Schema.decodeUnknownSync(TabStorage.Panes)({ tab: { terminal: "yes" } })).toThrow()
+    const panes = Codec.decodeOrThrow(TabStorage.Panes, { tab: { terminal: true, terminalHeight: 300 } })
+    expect(TabStorage.Panes.encode(panes)).toEqual({ tab: { terminal: true, terminalHeight: 300 } })
+    expect(() => Codec.decodeOrThrow(TabStorage.Panes, { tab: { terminal: "yes" } })).toThrow()
  })
 })

@@ -209,3 +208,5 @@ describe("closed tab stack", () => {
    expect(nextTabAfterClose([sessionTab("a")], 0, true)).toBeNull()
  })
 })
+
+
@@ -9,8 +9,7 @@
  justify-content: center;
 }

-[data-titlebar-tab],
-[data-titlebar-tab-action] {
+[data-titlebar-tab] {
  --tab-base: var(--v2-background-bg-deep);
  --tab-overlay: transparent;
  background: linear-gradient(var(--tab-overlay), var(--tab-overlay)), var(--tab-base);
@@ -69,14 +68,6 @@
  --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,10 +351,9 @@ 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:text-v2-text-text-base 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: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"
                  onClick={toggleHome}
                  aria-label={language.t("home.title")}
                  aria-pressed={layout.route().type === "home"}
@@ -651,9 +650,8 @@ 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: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:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base"
                              onClick={openNewTab}
                              aria-label={language.t("command.session.new")}
                            >
@@ -1,13 +1,13 @@
 import { expect, test } from "bun:test"
-import { Schema } from "effect"
 import { HighlightsStore } from "./highlights"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"

 test("highlight persistence defaults missing or invalid versions and round-trips valid versions", () => {
-  const decode = Schema.decodeUnknownSync(Persistence.withInitial(HighlightsStore, { version: undefined }))
+  const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(HighlightsStore, { version: undefined }), input))
  expect(decode({})).toEqual({ version: undefined })
  expect(decode({ version: null })).toEqual({ version: undefined })
  const value = decode({ version: "1.2.3", legacy: true })
  expect(value).toEqual({ version: "1.2.3" })
-  expect(Schema.encodeSync(HighlightsStore)(value)).toEqual(value)
+  expect(HighlightsStore.encode(value)).toEqual(value)
 })
+
@@ -1,18 +1,18 @@
 import { createEffect, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
-import { Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import { createSimpleContext } from "@opencode/ui/context"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { usePlatform } from "@/runtime/platform/platform"
 import { useSettings } from "@/settings/model"
 import { persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
+
 import { DialogReleaseNotes, type Highlight } from "@/shell/updates/release-notes"

 const CHANGELOG_URL = "https://opencode.ai/changelog.json"

-export const HighlightsStore = Persistence.struct({
-  version: Schema.UndefinedOr(Schema.String),
+export const HighlightsStore = Codec.struct({
+  version: Codec.undefinedOr(Codec.string),
 })

 type ParsedRelease = {
@@ -233,3 +233,4 @@ export const { use: useHighlights, provider: HighlightsProvider } = createSimple
    }
  },
 })
+
@@ -1,20 +1,19 @@
 import type { FileContent } from "@/runtime/server/types"
-import { Schema } from "effect"
-import { Persistence } from "@/runtime/persistence/schema"
+import { Codec } from "@/runtime/persistence/codec"

-export const FileSelection = Persistence.struct({
-  startLine: Schema.Number,
-  startChar: Schema.Number,
-  endLine: Schema.Number,
-  endChar: Schema.Number,
+export const FileSelection = Codec.struct({
+  startLine: Codec.number,
+  startChar: Codec.number,
+  endLine: Codec.number,
+  endChar: Codec.number,
 })
 export type FileSelection = typeof FileSelection.Type

-export const SelectedLineRange = Persistence.struct({
-  start: Schema.Number,
-  end: Schema.Number,
-  side: Persistence.optional(Schema.Literals(["additions", "deletions"])),
-  endSide: Persistence.optional(Schema.Literals(["additions", "deletions"])),
+export const SelectedLineRange = Codec.struct({
+  start: Codec.number,
+  end: Codec.number,
+  side: Codec.lenientOptional(Codec.literals(["additions", "deletions"])),
+  endSide: Codec.lenientOptional(Codec.literals(["additions", "deletions"])),
 })
 export type SelectedLineRange = typeof SelectedLineRange.Type

@@ -44,3 +43,4 @@ export function selectionFromLines(range: SelectedLineRange): FileSelection {
    endChar: 0,
  }
 }
+
@@ -1,8 +1,7 @@
 import { createEffect, createRoot } from "solid-js"
 import { produce } from "solid-js/store"
-import { Schema } from "effect"
+import { Codec } from "@/runtime/persistence/codec"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Persistence } from "@/runtime/persistence/schema"
 import { createScopedCache } from "@/runtime/server/scoped-cache"
 import { SelectedLineRange } from "./types"
 import type { ServerScope } from "@/runtime/server/scope"
@@ -11,14 +10,14 @@ const WORKSPACE_KEY = "__workspace__"
 const MAX_FILE_VIEW_SESSIONS = 20
 const MAX_VIEW_FILES = 500

-const FileViewSchema = Persistence.struct({
-  scrollTop: Persistence.optional(Schema.Finite),
-  scrollLeft: Persistence.optional(Schema.Finite),
-  selectedLines: Persistence.optional(Schema.NullOr(SelectedLineRange)),
+const FileViewSchema = Codec.struct({
+  scrollTop: Codec.lenientOptional(Codec.number),
+  scrollLeft: Codec.lenientOptional(Codec.number),
+  selectedLines: Codec.lenientOptional(Codec.nullOr(SelectedLineRange)),
 })

-export const FileViewsSchema = Schema.Struct({
-  file: Persistence.record(Persistence.fallback(FileViewSchema, () => ({}))),
+export const FileViewsSchema = Codec.struct({
+  file: Codec.lenientRecord(Codec.fallback(FileViewSchema, () => ({}))),
 })

 function normalizeSelectedLines(range: SelectedLineRange): SelectedLineRange {
@@ -150,3 +149,4 @@ export function createFileViewCache(scope: ServerScope) {
    clear: () => cache.clear(),
  }
 }
+
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/cli",
-  "version": "2.0.11",
+  "version": "2.0.10",
  "type": "module",
  "license": "MIT",
  "bin": {
@@ -1,8 +1,7 @@
 #!/usr/bin/env bun

 import { NodeRuntime, NodeServices } from "@effect/platform-node"
-import { Cause, Effect } from "effect"
-import { getErrorReported } from "effect/Runtime"
+import { Effect } from "effect"
 import { Commands } from "./commands/commands"
 import { Runtime } from "./framework/runtime"
 import { Observability } from "@opencode/util/observability"
@@ -131,15 +130,5 @@ Effect.gen(function* () {
  Effect.provide(NodeServices.layer),
  Effect.scoped,
  Effect.tap(() => Effect.sync(() => process.exit(process.exitCode ?? 0))),
-  // 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 }),
+  NodeRuntime.runMain,
 )
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/client",
-  "version": "2.0.11",
+  "version": "2.0.10",
  "type": "module",
  "license": "MIT",
  "repository": {
@@ -6,8 +6,6 @@
 - 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 enumerable }`, a
+      crosses as an array, a URLSearchParams as its query string, an Error as `{ name, message, ...own }`, 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,11 +38,8 @@ 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.
- [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.
+- [ ] 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"`.

 ## Values and literals

@@ -97,8 +94,7 @@ 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. `null`, `undefined`, and other
-      non-objects iterate nothing. An un-awaited promise throws rather than iterating.
+- [x] `for...in` over own keys of plain objects, arrays, strings, and tool references; other values iterate nothing.
 - [x] Unlabeled `break` and `continue`.
 - [x] `try`, `catch`, optional catch bindings, and `finally`.
 - [x] `throw` with arbitrary values.
@@ -112,8 +108,7 @@ 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. 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] Synchronous and `async` functions.
 - [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
@@ -148,6 +143,7 @@ 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,
@@ -184,8 +180,7 @@ 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. `Error.isError`
-      is true for every Error value.
+      `new Error(message, { cause })` installs a non-enumerable `cause` when the option is present.
 - [x] Arithmetic operators: `+`, `-`, `*`, `/`, `%`, and `**`.
 - [x] Equality and ordering: `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, and `>=`.
 - [x] Bitwise operators: `&`, `|`, `^`, `~`, `<<`, `>>`, and `>>>`.
@@ -275,9 +270,8 @@ 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]"`, `"[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`.
+- [x] `Object.prototype` methods on values: `toString` (`"[object Array]"`), `toLocaleString`, `valueOf`,
+      `hasOwnProperty`, `isPrototypeOf`, and `propertyIsEnumerable`.

 ## Arrays

@@ -291,14 +285,12 @@ 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`, `join`, and `toLocaleString` (each element's
-      `toLocaleString`, holes and nullish elements as empty strings).
+- [x] Access/copying: `at`, `slice`, `concat`, `flat`, `with`, and `join`.
 - [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. JavaScript gives each collection its own; the difference is not observable here because
-      `Object.getPrototypeOf` is not exposed.
+      shares one prototype, which is only observable through `getPrototypeOf`.
 - [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`.
@@ -311,13 +303,12 @@ 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. `indexOf()` and `lastIndexOf()` with no argument already search for
-      `undefined`; `includes()` still requires a value.
+      interpreter requires numbers and strings; `includes()`/`indexOf()` with no argument should search for
+      `undefined`.

 ## Strings

- [x] Case/normalization: `toLowerCase`, `toUpperCase`, `normalize`, and the `toLocaleLowerCase`/`toLocaleUpperCase`
-      aliases, which ignore their locale argument and apply the default Unicode casing.
+- [x] Case/normalization: `toLowerCase`, `toUpperCase`, `normalize`.
 - [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`.
@@ -341,8 +332,7 @@ 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`, `valueOf`, and `toLocaleString`, which
-      always formats as `en-US` (`"1,234.5"`) so output does not depend on the host.
+- [x] Number formatting: `toFixed`, `toPrecision`, `toExponential`, `toString`, and `valueOf`.
 - [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`.
@@ -355,8 +345,7 @@ 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.` or `search(...).catch is not a function.` Unknown `Promise` statics keep
-      their descriptive error.
+      example `Math.sum 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(...)`.
@@ -390,8 +379,6 @@ 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.
@@ -417,7 +404,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262

 - [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`, `forEach`, `getOrInsert`, and `getOrInsertComputed`.
+- [x] Map `get`, `set`, `has`, `delete`, `clear`, `size`, and `forEach`.
 - [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()`
@@ -438,8 +425,7 @@ 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 are their href in `JSON.stringify` and at the host boundary. URLSearchParams are `{}` in
-      `JSON.stringify` and their query string at the host boundary.
+- [x] URL values serialize to their href; URLSearchParams serialize to `{}`.

 ## Uint8Array

@@ -484,8 +470,7 @@ 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, message, `cause`, and own enumerable data, and a `__proto__` key is
-      dropped. Functions, generators,
+      errors cross as errors with their name and message, 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
@@ -510,10 +495,8 @@ 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 `[]` 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.
+      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.
 - [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
@@ -522,9 +505,8 @@ 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 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.
+      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.
 - [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.11",
+  "version": "2.0.10",
  "description": "Effect-native confined code execution over schema-described tools",
  "type": "module",
  "license": "MIT",
@@ -15,7 +15,6 @@ import {
  Obj,
  PromiseObj,
  record,
-  type Value,
  SetObj,
  URLSearchParamsObj,
  HeadersObj,
@@ -24,14 +23,14 @@ import { typeofValue } from "./interpreter/references.js"

 export type Json = Schema.Json

-type Replacer<R> = (args: Array<Value>) => Effect.Effect<Value, unknown, R>
+type Replacer<R> = (args: Array<unknown>) => Effect.Effect<unknown, 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: Value, replacer?: Replacer<R>) =>
+export const toJson = <R>(ctx: Interpreter<R>, value: unknown, replacer?: Replacer<R>) =>
  walk(ctx, value, replacer, false)

 /**
@@ -39,11 +38,11 @@ export const toJson = <R>(ctx: Interpreter<R>, value: Value, replacer?: Replacer
 * 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: Value) => walk(ctx, value, undefined, true)
+export const toBoundary = <R>(ctx: Interpreter<R>, value: unknown) => walk(ctx, value, undefined, true)

 const walk = <R>(
  ctx: Interpreter<R>,
-  value: Value,
+  value: unknown,
  replacer: Replacer<R> | undefined,
  boundary: boolean,
 ): Effect.Effect<Json | undefined, unknown, R> => {
@@ -105,7 +104,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: Json | undefined): Value => {
+export const fromJson = <R>(ctx: Interpreter<R>, value: unknown): unknown => {
  if (value === null || typeof value !== "object") return value
  if (Array.isArray(value))
    return new Arr(
@@ -1,12 +1,12 @@
 import { Effect, Exit } from "effect"
+import { coerceToNumber, coerceToString } from "../stdlib/value.js"
 import type { Interpreter } from "./interpreter.js"
-import { primitivePrototype } from "./intrinsics.js"
 import { typeError } from "./model.js"
-import { Callable, get, Native, DateObj, Obj, coerceToNumber, coerceToString, type Value } from "./objects.js"
+import { Callable, get, Native, DateObj, Obj } from "./objects.js"
 import { typeofValue } from "./references.js"

 export type IteratorCursor<R> = {
-  readonly next: Effect.Effect<{ readonly done: boolean; readonly value: Value }, unknown, R>
+  readonly next: Effect.Effect<{ readonly done: boolean; readonly value: unknown }, unknown, R>
  readonly close: Effect.Effect<void, unknown, R>
 }

@@ -26,9 +26,9 @@ export const preserveConsumerError = <A, R>(
 */
 export const toPrimitive = <R>(
  ctx: Interpreter<R>,
-  value: Value,
+  value: unknown,
  hint: "number" | "string" | "default",
-): Effect.Effect<Value, unknown, R> => {
+): Effect.Effect<unknown, 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,31 +43,24 @@ export const toPrimitive = <R>(
  })
 }

-/** 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) =>
+export const toPrimitiveString = <R>(ctx: Interpreter<R>, value: unknown) =>
  Effect.map(toPrimitive(ctx, value, "string"), coerceToString)

-export const toPrimitiveNumber = <R>(ctx: Interpreter<R>, value: Value) =>
+export const toPrimitiveNumber = <R>(ctx: Interpreter<R>, value: unknown) =>
  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: Value): value is Callable =>
+export const isSupportedCallback = (value: unknown): value is Callable =>
  value instanceof Callable && !(value instanceof Native && !value.callback)

 export const applyCollectionCallback = <R>(
  ctx: Interpreter<R>,
-  callback: Value,
+  callback: unknown,
  name: string,
-): ((args: Array<Value>) => Effect.Effect<Value, unknown, R>) => {
+): ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>) => {
  if (!isSupportedCallback(callback)) {
    if (typeofValue(callback) === "function") {
      throw typeError(
@@ -6,21 +6,10 @@ 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,
-  coerceToString,
-  type Value,
-} from "./objects.js"
+import { type Callable, define, get, has, hidden, type Native, Arr, ErrorObj, Obj } 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) {
@@ -97,7 +86,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): Value => {
+export const materialize = <R>(ctx: Interpreter<R>, thrown: unknown): unknown => {
  if (thrown instanceof Throw) return thrown.value
  const builtins = ctx.builtins
  if (thrown instanceof PendingThrow) {
@@ -124,7 +113,7 @@ const errorToString = (self: Obj): string => {

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

 const constructAggregateErrorValue = <R>(
  ctx: Interpreter<R>,
-  args: Array<Value>,
+  args: Array<unknown>,
  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<Value> = []
+    const errors: Array<unknown> = []
    while (true) {
      const step = yield* cursor.next
      if (step.done) {
@@ -155,7 +144,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<Value>, newTarget: Callable) => {
+  const construct = (args: Array<unknown>, newTarget: Callable) => {
    const proto = prototypeFrom(newTarget, prototype)
    const created =
      type === "AggregateError"
@@ -179,7 +168,6 @@ 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,7 +4,6 @@ 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"
@@ -14,7 +13,7 @@ export const executeProgram = <R>(
  prepared: ToolRuntime.Prepared<R>,
  limits: ResolvedExecutionLimits,
  hooks: ToolRuntime.Hooks<R>,
-  globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, Value]>,
+  globals?: (ctx: Interpreter<R>) => ReadonlyArray<readonly [string, unknown]>,
 ): Effect.Effect<Result, never, R> => {
  if (code.trim().length === 0) {
    return Effect.succeed({
@@ -1,5 +1,6 @@
 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"
@@ -7,7 +8,9 @@ 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,
@@ -16,17 +19,18 @@ import {
  Bytes,
  DateObj,
  ErrorObj,
-  HeadersObj,
+  GeneratorObj,
+  IteratorObj,
  MapObj,
  Obj,
+  PromiseObj,
  RegExpObj,
  SetObj,
  URLObj,
  URLSearchParamsObj,
-  coerceToString,
-  type Value,
+  HeadersObj,
 } from "./objects.js"
-import { describeValue, isOpaque } from "./references.js"
+import { describeValue } from "./references.js"

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

-  const toHost = (value: Value, label: string, depth = 0, seen = new Set<object>()): unknown => {
+  const toHost = (value: unknown, 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 (isPrimitive(value)) return value
-    if (!(value instanceof Obj) || isOpaque(value)) {
+    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
+    ) {
      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")
@@ -68,12 +89,19 @@ export const extensionGlobals = <R>(
      seen.delete(value)
      return copied
    }
-    const copied = value.toHost(next)
+    const copied =
+      value instanceof Arr
+        ? value.items.map(next)
+        : Object.fromEntries(
+            entries(value)
+              .filter(([key]) => key !== "__proto__")
+              .map(([key, item]) => [key, next(item)]),
+          )
    seen.delete(value)
    return copied
  }

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

 // The primitives the interpreter operates on; symbols and BigInts are not among them.
-const isPrimitive = (value: unknown): value is string | number | boolean | null | undefined =>
+const isPrimitive = (value: unknown): boolean =>
  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, type Value } from "./objects.js"
+import { define, hidden, GeneratorObj } 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: Value, args: Array<Value>) => {
+      (thisValue: unknown, args: Array<unknown>) => {
        const generator = receiver(GeneratorObj, thisValue, `${label}.prototype.${kind}`)
-        const requested = generator.request(kind, args[0]) as Effect.Effect<Value, unknown, R>
+        const requested = generator.request(kind, args[0]) as Effect.Effect<unknown, unknown, R>
        return generator.asynchronous ? ctx.pending.create(requested) : requested
      },
    ]
@@ -1,5 +1,4 @@
 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"
@@ -52,7 +51,7 @@ const symbolGlobal = <R>(ctx: Interpreter<R>) => {
  return symbol
 }

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

 // A table rather than a list so the names are known before any runtime exists.
 const table: Record<string, Factory> = {
@@ -101,7 +100,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, Value]> => {
+export const globals = <R>(ctx: Interpreter<R>): ReadonlyArray<readonly [string, unknown]> => {
  generatorGlobals(ctx)
  iteratorGlobals(ctx)
  return Object.entries(table).map(([name, factory]) => [name, factory(ctx)] as const)
@@ -32,7 +32,6 @@ import type {
  Statement,
  Super,
  SwitchStatement,
-  Literal,
  TemplateLiteral,
  ThrowStatement,
  TryStatement,
@@ -63,7 +62,7 @@ import {
 } from "./model.js"
 import { checkStringLength } from "./limits.js"
 import { locate, materialize } from "./errors.js"
-import { type Builtins, primitivePrototype } from "./intrinsics.js"
+import type { Builtins } from "./intrinsics.js"
 import { globals } from "./globals.js"
 import {
  assign,
@@ -76,16 +75,20 @@ import {
  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"
@@ -93,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 { compoundOperators } from "../stdlib/value.js"
+import { coerceToNumber, coerceToString, 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.
@@ -107,36 +110,24 @@ const loopExit = (result: StatementResult, labels: ReadonlySet<string> | undefin
  return undefined
 }

-// 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}(...)`
+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}`
  }
-  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}`
+  return "The called value"
 }

 // OrdinaryHasInstance: walk the left operand's chain looking for the constructor's `prototype`.
-// 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 => {
+const instanceofValue = (lhs: unknown, rhs: unknown, node: AstNode): boolean => {
  if (!(rhs instanceof Callable)) {
    throw typeError("The right-hand side of 'instanceof' is not callable.", node)
  }
@@ -233,7 +224,7 @@ const loopDeclaration = (left: VariableDeclaration | Pattern, statement: "for...

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

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

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

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

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

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

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

-  iterate(value: Value) {
+  iterate(value: unknown) {
    return this.root.iterate(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<Value>,
-  ): Effect.Effect<Value, unknown, R> {
+    args: Array<unknown>,
+  ): Effect.Effect<unknown, unknown, R> {
    const ctx = this
    return Effect.gen(function* () {
      const json = yield* Effect.forEach(args, (arg) => toBoundary(ctx, arg))
@@ -330,7 +321,7 @@ class Frame<R> {
    private depth = 0,
  ) {}

-  run(program: Program): Effect.Effect<Value, unknown, R> {
+  run(program: Program): Effect.Effect<unknown, unknown, R> {
    const self = this
    // Keep top-level declarations separate so they can shadow builtins.
    this.scopes.push()
@@ -338,7 +329,7 @@ class Frame<R> {
      self.predeclareLexical(program.body)
      self.hoistFunctions(program.body)
      self.hoistVars(program.body)
-      let value: Value = undefined
+      let value: unknown = undefined
      for (const [index, statement] of program.body.entries()) {
        if (index === program.body.length - 1 && statement.type === "ExpressionStatement") {
          value = yield* self.evaluateExpression(statement.expression)
@@ -363,12 +354,15 @@ 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<Value>): Effect.Effect<PromiseObj, never, R> {
+  private createToolCallPromise(
+    path: ReadonlyArray<string>,
+    args: Array<unknown>,
+  ): 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<Value, unknown, never> {
+  await(promise: PromiseObj): Effect.Effect<unknown, unknown, never> {
    const pending = this.ctx.pending
    return Effect.suspend(() => {
      pending.markObserved(promise)
@@ -459,7 +453,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<Value, unknown, R> {
+  private evaluateNamed(node: Expression, name: string): Effect.Effect<unknown, unknown, R> {
    if (node.type === "ArrowFunctionExpression" || (node.type === "FunctionExpression" && !node.id)) {
      return Effect.sync(() => this.createFunction(node, name))
    }
@@ -661,7 +655,7 @@ class Frame<R> {
      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 iterable value, received ${describeValue(right)}.`,
+          `${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, URLSearchParams, or Headers, or custom iterator value.`,
          node,
        )
      }
@@ -677,7 +671,7 @@ class Frame<R> {
      }
      const assignment = left.type === "VariableDeclaration" ? undefined : left

-      const evaluateBody = (value: Value) =>
+      const evaluateBody = (value: unknown) =>
        Effect.gen(function* () {
          if (declared?.lexical) {
            self.scopes.push()
@@ -726,7 +720,7 @@ class Frame<R> {
    )
  }

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

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

-  iterate(value: Value, node?: AstNode) {
+  iterate(value: unknown, node?: AstNode) {
    const cursor = this.hostCursor(value)
    if (cursor !== undefined) return Effect.succeed(cursor)
    const self = this
@@ -766,24 +760,40 @@ class Frame<R> {
    )
  }

-  private hostCursor(value: Value) {
+  private hostCursor(value: unknown) {
    const iterator =
-      typeof value === "string"
-        ? value[Symbol.iterator]()
-        : value instanceof Obj
-          ? value.iterator(this.ctx.builtins)
-          : undefined
+      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
    return {
      next: Effect.sync(() => {
        const step = iterator.next()
-        return { done: Boolean(step.done), value: step.value }
+        return {
+          done: Boolean(step.done),
+          value: Array.isArray(step.value) ? new Arr(proto, step.value) : step.value,
+        }
      }),
      close: Effect.void,
    }
  }

-  private customIterator(value: Value, node: AstNode | undefined, allowAsync = true) {
+  private customIterator(value: unknown, 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)
@@ -873,18 +883,18 @@ class Frame<R> {
    })
  }

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

-  private requireIteratorMethod(value: Value, context: string, node?: AstNode): Value {
+  private requireIteratorMethod(value: unknown, context: string, node?: AstNode): unknown {
    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: Value, node: AstNode): Array<string> {
+  private enumerableKeys(value: unknown, 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))
@@ -1048,7 +1058,7 @@ class Frame<R> {

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

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

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

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

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

-  private evaluateNewExpression(node: NewExpression): Effect.Effect<Value, unknown, R> {
+  private evaluateNewExpression(node: NewExpression): Effect.Effect<unknown, unknown, R> {
    const self = this
    return Effect.gen(function* () {
      const callee = yield* self.evaluateExpression(node.callee)
@@ -1294,7 +1305,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) ?? "The called value"
+        const name = calleeDescription(node.callee)
        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.`
@@ -1308,7 +1319,7 @@ class Frame<R> {
    })
  }

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

-  private applyBinaryOperator(operator: string, lhs: Value, rhs: Value, node: AstNode): Value {
+  private applyBinaryOperator(operator: string, lhs: unknown, rhs: unknown, node: AstNode): unknown {
    if (operator === "===") return lhs === rhs
    if (operator === "!==") return lhs !== rhs
    if (operator === "in" && rhs instanceof Obj && !containsOpaqueReference(lhs)) {
@@ -1330,9 +1341,14 @@ class Frame<R> {
    if (containsOpaqueReference(lhs) || containsOpaqueReference(rhs)) {
      throw invalidData("Binary operators require data values.", node)
    }
-    // 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)
+    // 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
+    }
    const bothObjects = lhs !== null && typeof lhs === "object" && rhs !== null && typeof rhs === "object"
    const l = coerceOperand(lhs)
    const r = coerceOperand(rhs)
@@ -1386,7 +1402,7 @@ class Frame<R> {
    }
  }

-  private evaluateLogicalExpression(node: LogicalExpression): Effect.Effect<Value, unknown, R> {
+  private evaluateLogicalExpression(node: LogicalExpression): Effect.Effect<unknown, 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)
@@ -1397,7 +1413,7 @@ class Frame<R> {
    })
  }

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

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

-  private evaluateUpdateExpression(node: UpdateExpression): Effect.Effect<Value, unknown, R> {
+  private evaluateUpdateExpression(node: UpdateExpression): Effect.Effect<unknown, unknown, R> {
    const operator = node.operator
    const argument = node.argument
    const prefix = node.prefix
@@ -1511,7 +1532,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: Value): number => {
+    const operand = (current: unknown): number => {
      if (containsOpaqueReference(current)) {
        throw invalidData(`'${operator}' requires a data value.`, argument)
      }
@@ -1540,7 +1561,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<Value, unknown, R> {
+  private evaluateCallExpression(node: CallExpression): Effect.Effect<unknown, unknown, R> {
    const callee = node.callee

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

-  private readMethod(node: MemberExpression): Effect.Effect<{ callable: Value; thisValue: Value }, unknown, R> {
+  private readMethod(node: MemberExpression): Effect.Effect<{ callable: unknown; thisValue: unknown }, 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 }
@@ -1569,12 +1590,12 @@ class Frame<R> {

  // The single dispatch for every invocation: call expressions and callbacks share it.
  call(
-    callable: Value,
-    thisValue: Value,
-    args: Array<Value>,
+    callable: unknown,
+    thisValue: unknown,
+    args: Array<unknown>,
    node?: AstNode,
    callee?: Expression,
-  ): Effect.Effect<Value, unknown, R> {
+  ): Effect.Effect<unknown, unknown, R> {
    const self = this
    return Effect.gen(function* () {
      if (callable instanceof ToolReference) {
@@ -1587,12 +1608,12 @@ class Frame<R> {
      if (callable instanceof Native) {
        return yield* self.native(() => (callable as Native<R>).call(thisValue, args), node)
      }
-      throw typeError(`${calleeDescription(callee) ?? "The called value"} is not a function.`, callee ?? node)
+      throw typeError(`${calleeDescription(callee)} 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<Value, unknown, R>, node?: AstNode): Effect.Effect<Value, unknown, R> {
+  private native(body: () => Effect.Effect<unknown, unknown, R>, node?: AstNode): Effect.Effect<unknown, unknown, R> {
    return Effect.provideService(
      Effect.catchDefect(Effect.suspend(body), (defect) => Effect.die(locate(defect, node))),
      CallSite,
@@ -1602,10 +1623,10 @@ class Frame<R> {

  private evaluateCallArguments(
    argNodes: ReadonlyArray<Expression | SpreadElement>,
-  ): Effect.Effect<Array<Value>, unknown, R> {
+  ): Effect.Effect<Array<unknown>, unknown, R> {
    const self = this
    return Effect.gen(function* () {
-      const args: Array<Value> = []
+      const args: Array<unknown> = []
      for (const argNode of argNodes) {
        if (argNode.type === "SpreadElement") {
          const spread = yield* self.evaluateExpression(argNode.argument)
@@ -1625,7 +1646,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<Value>, node?: AstNode): Effect.Effect<Value, unknown, R> {
+  invokeFunction(fn: Fn, args: Array<unknown>, node?: AstNode): Effect.Effect<unknown, unknown, R> {
    const self = this
    return Effect.flatMap(CallSite, (site) => {
      const depth = Math.max(self.depth, site.depth) + 1
@@ -1672,16 +1693,16 @@ class Frame<R> {

  private createGenerator(
    invocation: Frame<R>,
-    run: Effect.Effect<Value, unknown, R>,
+    run: Effect.Effect<unknown, 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: Value, done: boolean) => record(builtins.Object, { value, done })
-    const request = (kind: GeneratorRequestKind, value: Value) => {
-      const request = { kind, value, response: Deferred.makeUnsafe<Value, unknown>() }
+    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>() }
      if (!asynchronous && state.active) return Effect.die(typeError("Generator is already running."))
      if (asynchronous && (state.completed || (!state.started && kind !== "next"))) {
        state.started = true
@@ -1752,7 +1773,7 @@ class Frame<R> {

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

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

-  private suspendGenerator(value: Value, node: AstNode): Effect.Effect<Value, unknown, R> {
+  private suspendGenerator(value: unknown, node: AstNode): Effect.Effect<unknown, 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 })))
@@ -1828,11 +1849,20 @@ class Frame<R> {
    })
  }

-  private delegateYield(value: Value, node: AstNode): Effect.Effect<Value, unknown, R> {
+  private delegateYield(value: unknown, node: AstNode): Effect.Effect<unknown, unknown, R> {
    const self = this
    return Effect.gen(function* () {
-      const cursor = self.hostCursor(value)
-      if (cursor !== undefined) {
+      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)
        while (true) {
          const step = yield* cursor.next
          if (step.done) return undefined
@@ -1856,7 +1886,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: Value = undefined
+      let input: unknown = undefined
      while (true) {
        const method = kind === "next" ? iterator.next : get(iterator.iterator, kind)
        if (method === undefined || method === null) {
@@ -1876,7 +1906,7 @@ class Frame<R> {
          node,
        )
        const done = Boolean(get(result, "done"))
-        const resultValue: Value =
+        const resultValue: unknown =
          self.generatorAsync && !iterator.asynchronous
            ? yield* self.awaitAsyncFromSyncValue(iterator, get(result, "value"), node, kind !== "return" && !done)
            : get(result, "value")
@@ -1885,7 +1915,7 @@ class Frame<R> {
          return resultValue
        }

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

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

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

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

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

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

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

-      // Strings own length and indexes; every other primitive property reads through the wrapper prototype.
+      // Primitives read through their wrapper prototype without being boxed; strings own length and indexes.
+      const builtins = self.ctx.builtins
      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 }
      }
-      const proto = primitivePrototype(self.ctx.builtins, objectValue)
-      if (proto !== undefined) return { target: proto, 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 }

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

-  private readReference(reference: MemberReference, node: MemberExpression): Value {
+  private readReference(reference: MemberReference, node: MemberExpression): unknown {
    // Reject unknown promise properties so a missing await cannot hide.
    if (reference.target instanceof PromiseObj && !has(reference.target, reference.key)) {
      throw invalidData(
@@ -2069,7 +2101,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: Value = target): Value {
+  private readProperty(target: Obj, key: PropertyKey, node: AstNode, receiver: unknown = target): unknown {
    try {
      return get(target, key, receiver)
    } catch (error) {
@@ -2077,7 +2109,7 @@ class Frame<R> {
    }
  }

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

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

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

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

-  private toPropertyKey(value: Value, node: AstNode): PropertyKey {
+  private toPropertyKey(value: unknown, 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, type Value } from "./objects.js"
+import { define, hidden, Native, Arr, ErrorObj, Obj } from "./objects.js"

 export const errorTypes = [
  "Error",
@@ -52,14 +52,6 @@ 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.
@@ -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, Value } from "./objects.js"
+import type { ErrorObj } 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: Value
+  value: unknown
  initialized?: boolean
 }

 export type StatementResult =
  | { kind: "none" }
-  | { kind: "return"; value: Value }
+  | { kind: "return"; value: unknown }
  | { 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: Value) {}
+  constructor(readonly value: unknown) {}
 }

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

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

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

 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, type Value } from "./objects.js"
+import { type Callable, define, frozen, hidden, Native, type NativeOptions, Obj } from "./objects.js"
 import { describeValue } from "./references.js"

-/** 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>
+/** A native function body: a plain value, a thrown `PendingThrow`, or an Effect. */
+export type Impl = (thisValue: unknown, args: Array<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: Value, args: Array<Value>): Effect.Effect<Value, unknown, R> => {
+  (thisValue: unknown, args: Array<unknown>): Effect.Effect<unknown, unknown, R> => {
    const result = impl(thisValue, args)
-    return Effect.isEffect(result) ? (result as Effect.Effect<Value, unknown, R>) : Effect.succeed(result)
+    return Effect.isEffect(result) ? (result as Effect.Effect<unknown, 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, Value>): void => {
+export const constants = (target: Obj, table: Record<string, unknown>): 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: Value,
+  thisValue: unknown,
  method: string,
 ): T => {
  if (thisValue instanceof cls) return thisValue
@@ -1,7 +1,5 @@
 import type { BlockStatement, Expression, Pattern } from "acorn"
 import type { Effect, Fiber } from "effect"
-import { ToolReference } from "../tool-runtime.js"
-import type { Builtins } from "./intrinsics.js"
 import { checkArrayLength } from "./limits.js"
 import {
  AsyncIteratorSymbol,
@@ -18,12 +16,12 @@ export type Attributes = {
  readonly configurable: boolean
 }

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

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

 /** Ordinary assignment: writable, enumerable, configurable. */
@@ -35,119 +33,33 @@ 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. Subclasses answer, in one place, how a
- * built-in kind of object prints, coerces, iterates, and crosses to the host.
- */
+/** An object owned by the program: own properties plus a prototype link. */
 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<Value> = [],
+    readonly items: Array<unknown> = [],
  ) {
    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}`
-  }
 }

-/** 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"
+export abstract class Callable extends Obj {
  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 {
@@ -165,8 +77,8 @@ export class Fn extends Callable {
  }
 }

-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 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 NativeOptions<R> = {
  readonly name: string
@@ -191,163 +103,79 @@ export class Native<R = never> extends Callable {
  }
 }

-export class PromiseObj extends Opaque {
-  override readonly tag = "Promise"
+export class PromiseObj extends Obj {
  constructor(
    proto: Obj,
-    readonly fiber: Fiber.Fiber<Value, unknown>,
+    readonly fiber: Fiber.Fiber<unknown, 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 Opaque {
-  override readonly tag = "Generator"
+export class GeneratorObj extends Obj {
  constructor(
    proto: Obj,
    readonly asynchronous: boolean,
-    readonly request: (kind: GeneratorRequestKind, value: Value) => Effect.Effect<Value, unknown, unknown>,
+    readonly request: (kind: GeneratorRequestKind, value: unknown) => Effect.Effect<unknown, 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 Opaque {
-  override readonly tag = "Iterator"
+export class IteratorObj extends Obj {
  constructor(
    proto: Obj,
-    readonly source: IteratorObject<Value, undefined>,
+    readonly iterator: IteratorObject<unknown>,
  ) {
    super(proto)
  }
-  override get describe() {
-    return "an iterator"
-  }
-  override iterator() {
-    return this.source
-  }
 }

-/** 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"
+export class DateObj extends Obj {
  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 Wrapper {
-  override readonly tag = "RegExp"
+export class RegExpObj extends Obj {
  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 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 MapObj extends Obj {
+  readonly map = new Map<unknown, 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 SetObj extends Obj {
+  readonly set = new Set<unknown>()
 }

-export class URLSearchParamsObj extends Wrapper {
-  override readonly tag = "URLSearchParams"
+export class URLSearchParamsObj extends Obj {
  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 Wrapper {
-  override readonly tag = "Headers"
+export class HeadersObj extends Obj {
  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 Wrapper {
-  override readonly tag = "URL"
+export class URLObj extends Obj {
  readonly searchParams: URLSearchParamsObj
  constructor(
    proto: Obj,
@@ -357,52 +185,30 @@ export class URLObj extends Wrapper {
    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 Wrapper {
-  override readonly tag = "Uint8Array"
+export class Bytes extends Obj {
  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()
-  }
 }

-/** 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
+/** 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

 const MAX_ARRAY_INDEX = 4_294_967_295

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

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

-const elements = (target: Indexed): Array<Value> | Uint8Array => (target instanceof Arr ? target.items : target.bytes)
+const elements = (target: Indexed): Array<unknown> | 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
@@ -441,18 +247,18 @@ export const own = (target: Obj, key: PropertyKey): Slot | undefined => {
  return target.props.get(name)
 }

-const read = (slot: Slot, receiver: Value): Value =>
+const read = (slot: Slot, receiver: unknown): unknown =>
  "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): Value => {
+export const getOwn = (target: Obj, key: PropertyKey): unknown => {
  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: Value = target): Value => {
+export const get = (target: Obj, key: PropertyKey, receiver: unknown = target): unknown => {
  for (let current: Obj | null = target; current !== null; current = current.proto) {
    const slot = own(current, key)
    if (slot !== undefined) return read(slot, receiver)
@@ -467,14 +273,14 @@ export const has = (target: Obj, key: PropertyKey): boolean => {
  return false
 }

-export const hasPrototype = (value: Value, proto: Obj): boolean => {
+export const hasPrototype = (value: unknown, 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: Value): boolean | undefined => {
+const writeElement = (target: Indexed, name: string | symbol, value: unknown): boolean | undefined => {
  const at = index(target, name)
  if (at !== undefined) {
    if (target instanceof Bytes) target.bytes[at] = typeof value === "number" ? value : Number(value)
@@ -490,7 +296,7 @@ const writeElement = (target: Indexed, name: string | symbol, value: Value): boo
 }

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

 /** [[DefineOwnProperty]] for a data property, ignoring the chain. */
-export const define = (target: Obj, key: PropertyKey, value: Value, attrs: Attributes = data): void => {
+export const define = (target: Obj, key: PropertyKey, value: unknown, attrs: Attributes = data): void => {
  const name = canonical(key)
  if (isIndexed(target) && writeElement(target, name, value) !== undefined) return
  target.props.set(name, { value, ...attrs })
@@ -569,9 +375,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, Value]> => keys(target).map((key) => [key, getOwn(target, key)])
+export const entries = (target: Obj): Array<[string, unknown]> => keys(target).map((key) => [key, getOwn(target, key)])

-export const record = (proto: Obj, fields: Record<string, Value>): Obj => {
+export const record = (proto: Obj, fields: Record<string, unknown>): Obj => {
  const target = new Obj(proto)
  for (const [key, value] of Object.entries(fields)) define(target, key, value)
  return target
@@ -2,7 +2,7 @@ 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, type Value } from "./objects.js"
+import { Callable, define, get, hidden, Arr, Fn, Obj, PromiseObj, record } 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"
@@ -10,7 +10,7 @@ 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: Value) => void) =>
+const capability = <R>(ctx: Interpreter<R>, name: string, settle: (value: unknown) => 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<Value, unknown, R>,
+    body: (self: { promise?: PromiseObj }) => Effect.Effect<unknown, 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<Value, unknown, R>): Effect.Effect<PromiseObj, never, R> {
+  create(effect: Effect.Effect<unknown, 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<Value, unknown>> {
+  await(promise: PromiseObj): Effect.Effect<Exit.Exit<unknown, unknown>> {
    return Fiber.await(promise.fiber)
  }

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

 export const resolvePromiseValue = <R>(
  ctx: Interpreter<R>,
-  value: Value,
+  value: unknown,
  own?: { promise?: PromiseObj },
-): Effect.Effect<Value, unknown, R> => {
+): Effect.Effect<unknown, 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<Value, unknown>()
+    const deferred = Deferred.makeUnsafe<unknown, 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,7 +131,7 @@ export const resolvePromiseValue = <R>(
  })
 }

-export const resolvePromise = <R>(ctx: Interpreter<R>, value: Value): Effect.Effect<PromiseObj, never, R> => {
+export const resolvePromise = <R>(ctx: Interpreter<R>, value: unknown): Effect.Effect<PromiseObj, never, R> => {
  if (value instanceof PromiseObj) return Effect.succeed(value)
  return ctx.pending.createWithSelf((self) => resolvePromiseValue(ctx, value, self))
 }
@@ -141,8 +141,8 @@ const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"]
 const invokePromiseMethod = <R>(
  ctx: Interpreter<R>,
  name: (typeof promiseStatics)[number],
-  args: Array<Value>,
-): Effect.Effect<Value, unknown, R> => {
+  args: Array<unknown>,
+): Effect.Effect<unknown, unknown, R> => {
  if (name === "resolve") {
    return resolvePromise(ctx, args[0])
  }
@@ -175,7 +175,7 @@ const invokePromiseMethod = <R>(
        )
      }
      if (name === "allSettled") {
-        const outcomes: Array<Value> = []
+        const outcomes: Array<unknown> = []
        for (const item of items) {
          const exit = yield* ctx.pending.await(item)
          if (Exit.isSuccess(exit)) {
@@ -223,8 +223,8 @@ const invokePromiseMethod = <R>(
 const instanceMethod = <R>(
  ctx: Interpreter<R>,
  name: "then" | "catch" | "finally",
-  thisValue: Value,
-  args: Array<Value>,
+  thisValue: unknown,
+  args: Array<unknown>,
 ): Effect.Effect<PromiseObj, unknown, R> => {
  const method = `Promise.prototype.${name}`
  const promise = receiver(PromiseObj, thisValue, method)
@@ -237,12 +237,12 @@ const instanceMethod = <R>(
  return chainReaction(ctx, promise, onFulfilled, onRejected, method)
 }

-const constructPromise = <R>(ctx: Interpreter<R>, executor: Value): Effect.Effect<PromiseObj, unknown, R> => {
+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<Value, unknown>()
+    const deferred = Deferred.makeUnsafe<unknown, unknown>()
    const promise = yield* ctx.pending.createWithSelf((self) =>
      Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(ctx, value, self)),
    )
@@ -262,10 +262,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: Value) {}
+  constructor(readonly value: unknown) {}
 }

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

-/** 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
+/** 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)
+}

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

 const never = () => false

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

-export const containsOpaqueReference = (value: Value): boolean =>
-  find(value, isOpaque, (current) => isRuntimeReference(current) && !isOpaque(current), 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())

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

-export const describeValue = (value: Value): string => {
+export const describeValue = (value: unknown): string => {
  if (value === null || value === undefined) return String(value)
-  if (value instanceof Obj) return value.describe
+  if (value instanceof Arr) return "an array"
+  if (value instanceof PromiseObj) return "an un-awaited Promise"
  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: Value): string => {
+export const typeofValue = (value: unknown): string => {
  if (value instanceof Callable) return "function"
  if (value instanceof ToolReference) return value.path.length > 0 ? "function" : "object"
  return typeof value
@@ -1,5 +1,4 @@
 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>>
@@ -16,7 +15,7 @@ export class ScopeStack {
    scope.set(name, { mutable, value: undefined, initialized: false })
  }

-  initialize(name: string, value: Value, node: AstNode): void {
+  initialize(name: string, value: unknown, 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)
@@ -25,7 +24,7 @@ export class ScopeStack {
    binding.initialized = true
  }

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

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

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

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

    if (!binding) {
@@ -2,24 +2,14 @@ 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,
-  coerceToNumber,
-  coerceToString,
-  type Value,
-} from "../interpreter/objects.js"
+import { define, get, hidden, Arr, GeneratorObj, IteratorObj, Obj } from "../interpreter/objects.js"
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js"
-import { applyCollectionCallback, invoke, preserveConsumerError } from "../interpreter/callback.js"
+import { applyCollectionCallback, 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: Value): { readonly length: number; readonly source: Obj } => {
+const arrayLikeSource = (source: unknown): { 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)
@@ -31,7 +21,7 @@ const arrayLikeSource = (source: Value): { readonly length: number; readonly sou
  )
 }

-const arrayFrom = <R>(ctx: Interpreter<R>, args: Array<Value>): Effect.Effect<Value, unknown, R> => {
+const arrayFrom = <R>(ctx: Interpreter<R>, args: Array<unknown>): Effect.Effect<unknown, unknown, R> => {
  const source = args[0]
  const proto = ctx.builtins.Array
  const apply =
@@ -43,14 +33,14 @@ const arrayFrom = <R>(ctx: Interpreter<R>, args: Array<Value>): Effect.Effect<Va
        throw typeError("Array.from expects a synchronous iterable or array-like value.")
      }
      const arrayLike = arrayLikeSource(source)
-      const values: Array<Value> = []
+      const values: Array<unknown> = []
      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<Value> = []
+    const values: Array<unknown> = []
    let index = 0
    while (true) {
      const step = yield* cursor.next
@@ -63,21 +53,21 @@ const arrayFrom = <R>(ctx: Interpreter<R>, args: Array<Value>): Effect.Effect<Va

 export const sortArray = <R>(
  ctx: Interpreter<R>,
-  target: Array<Value>,
-  comparator: Value,
+  target: Array<unknown>,
+  comparator: unknown,
  name: string,
-): Effect.Effect<Array<Value>, unknown, R> => {
+): Effect.Effect<Array<unknown>, 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<Value>): Effect.Effect<Array<Value>, unknown, R> => {
+  const mergeSort = (items: Array<unknown>): Effect.Effect<Array<unknown>, 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<Value> = []
+      const merged: Array<unknown> = []
      let leftIndex = 0
      let rightIndex = 0
      while (leftIndex < left.length && rightIndex < right.length) {
@@ -98,8 +88,8 @@ export const sortArray = <R>(
 export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
  const builtins = ctx.builtins
  const proto = builtins.Array
-  const wrap = (items: Array<Value>) => new Arr(proto, items)
-  const construct = (args: Array<Value>, into: Obj): Arr => {
+  const wrap = (items: Array<unknown>) => new Arr(proto, items)
+  const construct = (args: Array<unknown>, 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])
@@ -119,8 +109,8 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
    ["from", 1, (_, args) => arrayFrom(ctx, args)],
  ])

-  const self = (thisValue: Value, name: string) => receiver(Arr, thisValue, `Array.prototype.${name}`)
-  const optNumber = (name: string, value: Value, label: string): number | undefined => {
+  const self = (thisValue: unknown, name: string) => receiver(Arr, thisValue, `Array.prototype.${name}`)
+  const optNumber = (name: string, value: unknown, label: string): number | undefined => {
    if (value === undefined) return undefined
    if (typeof value !== "number") {
      throw typeError(`Array.${name} expects ${label} to be a number.`)
@@ -132,11 +122,11 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
    name: string,
    length: number,
    body: (
-      target: Array<Value>,
+      target: Array<unknown>,
      receiver: Arr,
-      apply: (args: Array<Value>) => Effect.Effect<Value, unknown, R>,
-      args: Array<Value>,
-    ) => Effect.Effect<Value, unknown, R>,
+      apply: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>,
+      args: Array<unknown>,
+    ) => Effect.Effect<unknown, unknown, R>,
  ): Method => [
    name,
    length,
@@ -224,7 +214,7 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
      "flat",
      0,
      (thisValue, args) => {
-        const flatten = (items: Array<Value>, depth: number): Array<Value> =>
+        const flatten = (items: Array<unknown>, depth: number): Array<unknown> =>
          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)
@@ -350,19 +340,6 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
        return target
      },
    ],
-    [
-      "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) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").items.keys())],
    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").items.values())],
    [
@@ -379,7 +356,7 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
    iterate("map", 1, (target, receiver, apply) =>
      Effect.gen(function* () {
        const length = target.length
-        const values: Array<Value> = []
+        const values: Array<unknown> = []
        values.length = length
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
@@ -391,7 +368,7 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
    iterate("flatMap", 1, (target, receiver, apply) =>
      Effect.gen(function* () {
        const length = target.length
-        const values: Array<Value> = []
+        const values: Array<unknown> = []
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
          const mapped = yield* apply([target[index], index, receiver])
@@ -404,7 +381,7 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
    iterate("filter", 1, (target, receiver, apply) =>
      Effect.gen(function* () {
        const length = target.length
-        const values: Array<Value> = []
+        const values: Array<unknown> = []
        for (let index = 0; index < length; index += 1) {
          if (!(index in target)) continue
          const item = target[index]
@@ -2,24 +2,13 @@ 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,
-  coerceToNumber,
-  coerceToString,
-  type Value,
-} from "../interpreter/objects.js"
+import { define, defineAccessor, get, hidden, Arr, Bytes, IteratorObj, Obj } 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: Value, name: string): Effect.Effect<Uint8Array, unknown, R> => {
+const collectBytes = <R>(ctx: Interpreter<R>, source: unknown, 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)
@@ -38,7 +27,7 @@ const collectBytes = <R>(ctx: Interpreter<R>, source: Value, name: string): Effe
  })
 }

-const constructBytes = <R>(ctx: Interpreter<R>, args: Array<Value>, proto: Obj) => {
+const constructBytes = <R>(ctx: Interpreter<R>, args: Array<unknown>, 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))
@@ -59,7 +48,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<Value>, from: (text: string) => Uint8Array) => {
+  const decode = (name: string, args: Array<unknown>, from: (text: string) => Uint8Array) => {
    if (typeof args[0] !== "string") throw typeError(`Uint8Array.${name} expects a string.`)
    try {
      return wrap(from(args[0]))
@@ -74,13 +63,13 @@ export const uint8ArrayGlobal = <R>(ctx: Interpreter<R>) => {
    ["fromHex", 1, (_, args) => decode("fromHex", args, (text) => Uint8Array.fromHex(text))],
  ])

-  const self = (thisValue: Value, name: string) => receiver(Bytes, thisValue, `Uint8Array.prototype.${name}`)
-  const optNumber = (name: string, value: Value, label: string): number | undefined => {
+  const self = (thisValue: unknown, name: string) => receiver(Bytes, thisValue, `Uint8Array.prototype.${name}`)
+  const optNumber = (name: string, value: unknown, 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<Value>) => new Arr(builtins.Array, items)
+  const wrapAll = (items: Array<unknown>) => 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)],
@@ -233,7 +222,8 @@ 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: Value, name: string) => receiver(TextDecoderObj, thisValue, `TextDecoder.prototype.${name}`)
+  const self = (thisValue: unknown, 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,16 +7,15 @@ import {
  get,
  getOwn,
  hidden,
+  isWrapper,
  Arr,
-  coerceToString,
  IteratorObj,
  MapObj,
  Obj,
  PromiseObj,
  SetObj,
-  type Value,
 } from "../interpreter/objects.js"
-import { describeValue, isOpaque } from "../interpreter/references.js"
+import { describeValue, isRuntimeReference } from "../interpreter/references.js"
 import {
  applyCollectionCallback,
  isSupportedCallback,
@@ -26,9 +25,9 @@ import {
 } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"

-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)) {
+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)) {
    throw invalidData(`Object.groupBy callback must return a data value, received ${describeValue(value)}.`)
  }
  return toPrimitiveString(ctx, value)
@@ -82,7 +81,7 @@ export const groupBy = <R>(ctx: Interpreter<R>, namespace: "Map" | "Object") =>
    })
  })

-const constructMap = <R>(ctx: Interpreter<R>, init: Value, proto: Obj) => {
+const constructMap = <R>(ctx: Interpreter<R>, init: unknown, proto: Obj) => {
  const target = new MapObj(proto)
  if (init === undefined || init === null) return Effect.succeed(target)
  return Effect.gen(function* () {
@@ -106,7 +105,7 @@ const constructMap = <R>(ctx: Interpreter<R>, init: Value, proto: Obj) => {
  })
 }

-const constructSet = <R>(ctx: Interpreter<R>, init: Value, proto: Obj) => {
+const constructSet = <R>(ctx: Interpreter<R>, init: unknown, proto: Obj) => {
  const target = new SetObj(proto)
  if (init === undefined || init === null) return Effect.succeed(target)
  return Effect.gen(function* () {
@@ -131,7 +130,8 @@ 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: Value, name: string) => receiver(MapObj, thisValue, `Map.prototype.${name}`)
+  const self = (thisValue: unknown, name: string) => receiver(MapObj, thisValue, `Map.prototype.${name}`)
+  const wrap = (items: Array<unknown>) => new Arr(builtins.Array, items)
  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,29 +145,6 @@ 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",
@@ -179,7 +156,17 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {
    ],
    ["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").iterator(builtins))],
+    [
+      "entries",
+      0,
+      (thisValue) =>
+        new IteratorObj(
+          builtins.Iterator,
+          self(thisValue, "entries")
+            .map.entries()
+            .map(([key, item]) => wrap([key, item])),
+        ),
+    ],
    [
      "forEach",
      1,
@@ -199,26 +186,26 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {

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

 const loadSetRecord = <R>(
  ctx: Interpreter<R>,
-  source: Value,
+  source: unknown,
  name: string,
 ): Effect.Effect<SetRecord<R>, unknown, R> => {
  if (source instanceof SetObj) {
    return Effect.succeed({
      size: source.set.size,
-      has: (item: Value) => Effect.succeed(source.set.has(item)),
+      has: (item: unknown) => 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: Value) => Effect.succeed(source.map.has(item)),
+      has: (item: unknown) => Effect.succeed(source.map.has(item)),
      keys: () => Effect.succeed(source.map.keys()),
    })
  }
@@ -237,10 +224,10 @@ const loadSetRecord = <R>(
    }
    return {
      size: Math.max(Math.trunc(size), 0),
-      has: (item: Value) => Effect.map(ctx.call(has, source, [item]), Boolean),
+      has: (item: unknown) => Effect.map(ctx.call(has, source, [item]), Boolean),
      keys: () =>
-        Effect.flatMap(ctx.call(keys, source, []), (result): Effect.Effect<Iterable<Value>> => {
-          if (result instanceof IteratorObj) return Effect.succeed(result.source)
+        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.`)
        }),
@@ -252,8 +239,8 @@ const setOperation = <R>(
  ctx: Interpreter<R>,
  target: SetObj,
  name: string,
-  source: Value,
-): Effect.Effect<Value, unknown, R> =>
+  source: unknown,
+): Effect.Effect<unknown, unknown, R> =>
  Effect.gen(function* () {
    const other = yield* loadSetRecord(ctx, source, name)
    const copy = () => {
@@ -332,8 +319,8 @@ export const setGlobal = <R>(ctx: Interpreter<R>) => {
    call: requiresNew("Set"),
    construct: (args, newTarget) => constructSet(ctx, args[0], prototypeFrom(newTarget, proto)),
  })
-  const self = (thisValue: Value, name: string) => receiver(SetObj, thisValue, `Set.prototype.${name}`)
-  const wrap = (items: Array<Value>) => new Arr(builtins.Array, items)
+  const self = (thisValue: unknown, name: string) => receiver(SetObj, thisValue, `Set.prototype.${name}`)
+  const wrap = (items: Array<unknown>) => new Arr(builtins.Array, items)
  const operation = (name: string): Method => [
    name,
    1,
@@ -1,8 +1,22 @@
 import { type Method, methods } from "../interpreter/native.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 {
+  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 type { Interpreter } from "../interpreter/interpreter.js"
+import { coerceToString } from "./value.js"

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

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

 const MAX_CONSOLE_DEPTH = 32

-const formatConsoleMessage = (name: string, args: Array<Value>): string => {
+const formatConsoleMessage = (name: string, args: Array<unknown>): 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] " : ""
@@ -37,27 +51,60 @@ const formatConsoleMessage = (name: string, args: Array<Value>): string => {
 }

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

-const formatConsoleValue = (value: Value, seen: Set<object>, depth: number): string => {
+const formatConsoleValue = (value: unknown, seen: Set<object>, depth: number): string => {
  if (value === null || value === undefined) return "null"
  if (typeof value === "string") return JSON.stringify(value)
-  if (!(value instanceof Obj)) return value instanceof ToolReference ? "[opaque reference]" : String(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 (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 {
-    return value.inspect((item) => formatConsoleValue(item, seen, depth + 1))
+    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(",")}}`
  } finally {
    seen.delete(value)
  }
 }

-const formatConsoleTable = (value: Value, columnsArgument: Value): string => {
+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 => {
  if (value === undefined) return "undefined"
  if (containsOpaqueReference(value)) return "[opaque reference]"
  const columns = columnsArgument instanceof Arr ? columnsArgument.items.map(String) : undefined
@@ -71,9 +118,9 @@ const formatConsoleTable = (value: Value, columnsArgument: Value): string => {
 }

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

-const consoleTableValues = (value: Value, columns: ReadonlyArray<string> | undefined): Record<string, Value> => {
+const consoleTableValues = (value: unknown, columns: ReadonlyArray<string> | undefined): Record<string, unknown> => {
  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))
@@ -91,7 +138,7 @@ const consoleTableValues = (value: Value, columns: ReadonlyArray<string> | undef
  return { Value: value }
 }

-const formatConsoleTableCell = (value: Value): string => {
+const formatConsoleTableCell = (value: unknown): string => {
  if (value === undefined) return ""
  if (typeof value === "string") return value
  return formatConsoleValue(value, new Set(), 0)
@@ -1,11 +1,12 @@
 import { Effect } from "effect"
 import { constructor, type Method, methods, prototypeFrom, receiver } from "../interpreter/native.js"
 import { rangeError } from "../interpreter/model.js"
-import { DateObj, Obj, coerceToNumber, coerceToString, type Value } from "../interpreter/objects.js"
+import { DateObj, Obj } 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<Value>, proto: Obj) => {
+const constructDate = <R>(ctx: Interpreter<R>, args: Array<unknown>, proto: Obj) => {
  if (args.length === 0) return Effect.succeed(new DateObj(proto, Date.now()))
  if (args.length === 1) {
    const arg = args[0]
@@ -82,7 +83,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: Value, name: string) => receiver(DateObj, thisValue, `Date.prototype.${name}`)
+  const self = (thisValue: unknown, 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()
@@ -104,13 +105,6 @@ 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,21 +1,11 @@
 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,
-  coerceToString,
-  isRuntimeReference,
-  type Value,
-} from "../interpreter/objects.js"
+import { define, entries, get, hidden, Arr, HeadersObj, IteratorObj, Obj } 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.
@@ -27,7 +17,7 @@ const attempt = <T>(run: () => T): T => {
  }
 }

-const constructHeaders = <R>(ctx: Interpreter<R>, init: Value, proto: Obj): Effect.Effect<HeadersObj, unknown, R> => {
+const constructHeaders = <R>(ctx: Interpreter<R>, init: unknown, 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* () {
@@ -50,10 +40,10 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
    call: requiresNew("Headers"),
    construct: (args, newTarget) => constructHeaders(ctx, args[0], prototypeFrom(newTarget, proto)),
  })
-  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 => {
+  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 => {
    if (args.length < count) throw typeError(`Headers.${name} requires ${count} argument${count === 1 ? "" : "s"}.`)
  }
  methods(builtins, proto, [
@@ -63,8 +53,7 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
      (thisValue, args) => {
        requireArgs("append", args, 2)
        const target = self(thisValue, "append").headers
-        attempt(() => target.append(arg(args, 0), arg(args, 1)))
-        return undefined
+        return attempt(() => target.append(arg(args, 0), arg(args, 1)))
      },
    ],
    [
@@ -73,8 +62,7 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
      (thisValue, args) => {
        requireArgs("delete", args, 1)
        const target = self(thisValue, "delete").headers
-        attempt(() => target.delete(arg(args, 0)))
-        return undefined
+        return attempt(() => target.delete(arg(args, 0)))
      },
    ],
    [
@@ -102,8 +90,7 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
      (thisValue, args) => {
        requireArgs("set", args, 2)
        const target = self(thisValue, "set").headers
-        attempt(() => target.set(arg(args, 0), arg(args, 1)))
-        return undefined
+        return attempt(() => target.set(arg(args, 0), arg(args, 1)))
      },
    ],
    // Iterator.from because Bun's Headers typings predate iterator helpers; the runtime iterators already have them.
@@ -117,7 +104,15 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
      0,
      (thisValue) => new IteratorObj(builtins.Iterator, Iterator.from(self(thisValue, "values").headers.values())),
    ],
-    ["entries", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries").iterator(builtins))],
+    [
+      "entries",
+      0,
+      (thisValue) =>
+        new IteratorObj(
+          builtins.Iterator,
+          Iterator.from(self(thisValue, "entries").headers.entries()).map(([key, value]) => wrap([key, value])),
+        ),
+    ],
    [
      "forEach",
      1,
@@ -11,7 +11,7 @@ export const iteratorGlobals = <R>(ctx: Interpreter<R>): void => {
      "next",
      0,
      (thisValue) => {
-        const step = receiver(IteratorObj, thisValue, "Iterator.prototype.next").source.next()
+        const step = receiver(IteratorObj, thisValue, "Iterator.prototype.next").iterator.next()
        return record(builtins.Object, { value: step.value, done: Boolean(step.done) })
      },
    ],
@@ -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, type Value } from "../interpreter/objects.js"
+import { get, keys, Arr, Obj, record, remove, set } 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<Value>): Effect.Effect<Value, unknown, R> => {
+const parse = <R>(ctx: Interpreter<R>, args: Array<unknown>): Effect.Effect<unknown, 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<Value>): Effect.Effect<Value,
  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<Value, unknown, R> =>
+  const visit = (holder: Obj, key: string): Effect.Effect<unknown, 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<Value>): Effect.Effect<Value,
  return visit(record(ctx.builtins.Object, { "": parsed }), "")
 }

-const stringify = <R>(ctx: Interpreter<R>, args: Array<Value>): Effect.Effect<Value, unknown, R> => {
+const stringify = <R>(ctx: Interpreter<R>, args: Array<unknown>): Effect.Effect<unknown, 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, type Value } from "../interpreter/objects.js"
+import { Obj } 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<Value>, index: number): number => {
+const number = (name: string, args: Array<unknown>, 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.`)
@@ -1,8 +1,7 @@
 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 } from "./value.js"
+import { coercion, coerceToString } from "./value.js"

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

-  const self = (thisValue: Value, name: string): number => {
+  const self = (thisValue: unknown, 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: Value): number | undefined => {
+  const optNum = (name: string, arg: unknown): 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,
@@ -90,7 +88,7 @@ export const booleanGlobal = <R>(ctx: Interpreter<R>) => {
    length: 1,
    call: coercion(ctx, "Boolean").call,
  })
-  const self = (thisValue: Value, name: string): boolean => {
+  const self = (thisValue: unknown, name: string): boolean => {
    if (typeof thisValue === "boolean") return thisValue
    throw typeError(`Boolean.prototype.${name} requires that 'this' be a Boolean.`)
  }
@@ -9,6 +9,7 @@ import {
  typeError,
 } from "../interpreter/model.js"
 import {
+  Callable,
  define,
  entries,
  enumerableKeys,
@@ -19,20 +20,23 @@ 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 { invoke, preserveConsumerError } from "../interpreter/callback.js"
+import { 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: Value, node?: AstNode): Obj => {
+export const enumerableSource = <R>(ctx: Interpreter<R>, label: string, value: unknown, node?: AstNode): Obj => {
  if (value === null || value === undefined) {
    throw typeError(`${label} cannot convert ${describeValue(value)} to an object.`, node)
  }
@@ -50,7 +54,7 @@ export const enumerableSource = <R>(ctx: Interpreter<R>, label: string, value: V
  return new Obj(ctx.builtins.Object)
 }

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

-const objectFromEntries = <R>(ctx: Interpreter<R>, source: Value): Effect.Effect<Obj, unknown, R> => {
+const objectFromEntries = <R>(ctx: Interpreter<R>, source: unknown): Effect.Effect<Obj, unknown, R> => {
  const out = new Obj(ctx.builtins.Object)
  return Effect.gen(function* () {
    const cursor = yield* ctx.iterate(source)
@@ -94,24 +98,29 @@ const objectFromEntries = <R>(ctx: Interpreter<R>, source: Value): Effect.Effect
  })
 }

-const classTag = (value: Value): string => {
+export const classTag = (value: unknown): string => {
  if (value === null) return "Null"
  if (value === undefined) return "Undefined"
-  if (value instanceof Obj) return value.tag
+  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 (typeof value === "string") return "String"
  if (typeof value === "number") return "Number"
  if (typeof value === "boolean") return "Boolean"
  return "Object"
 }

-const propertyKey = (value: Value): PropertyKey =>
+const propertyKey = (value: unknown): 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<Value>): Value => {
+  const construct = (args: Array<unknown>): unknown => {
    const first = args[0]
    if (first === null || first === undefined) return new Obj(builtins.Object)
    if (first instanceof Obj) return first
@@ -187,7 +196,7 @@ export const objectGlobal = <R>(ctx: Interpreter<R>) => {
        true,
    ],
    ["toString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
-    ["toLocaleString", 0, (thisValue) => invoke(ctx, thisValue, "toString", "Object.prototype.toLocaleString")],
+    ["toLocaleString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
    [
      "valueOf",
      0,
@@ -2,18 +2,9 @@ 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,
-  coerceToNumber,
-  coerceToString,
-  type Value,
-} from "../interpreter/objects.js"
+import { define, defineAccessor, Arr, Obj, RegExpObj, record } from "../interpreter/objects.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
+import { coerceToNumber, coerceToString } from "./value.js"

 const flagProperties = [
  "hasIndices",
@@ -32,7 +23,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: Value, method: string, extraFlags = ""): RegExp => {
+export const toHostRegex = (arg: unknown, 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
@@ -62,7 +53,7 @@ export const matchToValue = (builtins: Builtins, match: RegExpMatchArray): Arr =
  return result
 }

-export const constructRegExp = (builtins: Builtins, args: Array<Value>, proto: Obj = builtins.RegExp): RegExpObj => {
+export const constructRegExp = (builtins: Builtins, args: Array<unknown>, 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]
@@ -105,7 +96,7 @@ export const regexpGlobal = <R>(ctx: Interpreter<R>) => {
    ],
  ])

-  const self = (thisValue: Value, name: string) => receiver(RegExpObj, thisValue, `RegExp.prototype.${name}`)
+  const self = (thisValue: unknown, 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,26 +1,16 @@
 import { Effect } from "effect"
-import { constructor, fn, type Impl, type Method, methods } from "../interpreter/native.js"
+import { constructor, fn, 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,
-  RegExpObj,
-  record,
-  coerceToNumber,
-  coerceToString,
-  type Value,
-} from "../interpreter/objects.js"
+import { define, hidden, Arr, IteratorObj, PromiseObj, RegExpObj, record } 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 { coercion } from "./value.js"
+import { coerceToNumber, coerceToString, coercion } from "./value.js"

 // console is intercepted by the interpreter before reaching here.
-const requireDataArgument = (name: string, index: number, arg: Value): Value => {
+const requireDataArgument = (name: string, index: number, arg: unknown): unknown => {
  if (containsOpaqueReference(arg)) {
    throw invalidData(`String.${name} expects argument ${index + 1} to be a data value.`)
  }
@@ -39,23 +29,21 @@ const replaceWithCallback = <R>(
  ctx: Interpreter<R>,
  value: string,
  name: "replace" | "replaceAll",
-  args: Array<Value>,
-): Effect.Effect<Value, unknown, R> => {
+  args: Array<unknown>,
+): Effect.Effect<unknown, 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<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 matches: Array<{ readonly match: string; readonly offset: number; readonly args: Array<unknown> }> = []
+  const collect = (...callbackArgs: Array<unknown>): string => {
    const match = callbackArgs[0]
-    const hasGroups = typeof callbackArgs.at(-1) === "object"
+    const groups = callbackArgs[callbackArgs.length - 1]
+    const hasGroups = groups !== null && typeof groups === "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.`)
    }
-    const args = callbackArgs.map((arg) => (typeof arg === "object" ? record(builtins.Object, arg) : arg))
-    matches.push({ match, offset, args })
+    if (hasGroups) callbackArgs[callbackArgs.length - 1] = record(builtins.Object, groups as Record<string, unknown>)
+    matches.push({ match, offset, args: callbackArgs })
    return match
  }

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

-  const self = (thisValue: Value, name: string): string => {
+  const self = (thisValue: unknown, name: string): string => {
    if (typeof thisValue === "string") return thisValue
    if (thisValue === null || thisValue === undefined) {
      throw typeError(`String.prototype.${name} called on null or undefined.`)
@@ -116,26 +107,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<Value>, index: number): string =>
+  const str = (name: string, args: Array<unknown>, index: number): string =>
    coerceToString(requireDataArgument(name, index, args[index]))
-  const num = (name: string, args: Array<Value>, index: number): number =>
+  const num = (name: string, args: Array<unknown>, index: number): number =>
    coerceToNumber(requireDataArgument(name, index, args[index]))
-  const optNum = (name: string, args: Array<Value>, index: number): number | undefined =>
+  const optNum = (name: string, args: Array<unknown>, index: number): number | undefined =>
    args[index] === undefined ? undefined : num(name, args, index)
-  const optStr = (name: string, args: Array<Value>, index: number): string | undefined =>
+  const optStr = (name: string, args: Array<unknown>, index: number): string | undefined =>
    args[index] === undefined ? undefined : str(name, args, index)
-  const rejectRegex = (name: string, args: Array<Value>): void => {
+  const rejectRegex = (name: string, args: Array<unknown>): 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<Value>) => ReturnType<Impl>,
-  ): Method => [name, length, (thisValue, args) => op(self(thisValue, name), args)]
+  const simple = (name: string, length: number, op: (value: string, args: Array<unknown>) => unknown): 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)
@@ -159,8 +150,6 @@ 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()),
@@ -227,7 +216,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<Value> = []
+      const matches: Array<unknown> = []
      for (const match of value.matchAll(pattern)) {
        checkArrayLength(matches.length + 1)
        matches.push(matchToValue(builtins, match))
@@ -7,17 +7,17 @@ import {
  entries,
  get,
  hidden,
+  isWrapper,
  Arr,
  IteratorObj,
  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: Value): string => (value instanceof URLObj ? value.url.href : coerceToString(value))
+const urlArgument = (value: unknown): 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<Value>, into: Obj): URLObj => {
+  const construct = (args: Array<unknown>, 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: Value, name: string) => receiver(URLObj, thisValue, `URL.prototype.${name}`)
+  const self = (thisValue: unknown, 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: Value, label: string): Effect.Effect<Array<string>, unknown, R> =>
+const readPair = <R>(ctx: Interpreter<R>, value: unknown, 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.`)
@@ -142,7 +142,7 @@ const readPair = <R>(ctx: Interpreter<R>, value: Value, label: string): Effect.E
 */
 export const readPairs = <R>(
  ctx: Interpreter<R>,
-  init: Value,
+  init: unknown,
  label: string,
 ): Effect.Effect<Array<[string, string]> | undefined, unknown, R> =>
  Effect.gen(function* () {
@@ -161,7 +161,7 @@ export const readPairs = <R>(

 const constructURLSearchParams = <R>(
  ctx: Interpreter<R>,
-  init: Value,
+  init: unknown,
  proto: Obj,
 ): Effect.Effect<URLSearchParamsObj, unknown, R> => {
  const wrap = (params: URLSearchParams) => new URLSearchParamsObj(proto, params)
@@ -177,6 +177,7 @@ 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.",
@@ -196,11 +197,11 @@ export const urlSearchParamsGlobal = <R>(ctx: Interpreter<R>) => {
    call: requiresNew("URLSearchParams"),
    construct: (args, newTarget) => constructURLSearchParams(ctx, args[0], prototypeFrom(newTarget, proto)),
  })
-  const self = (thisValue: Value, name: string) =>
+  const self = (thisValue: unknown, name: string) =>
    receiver(URLSearchParamsObj, thisValue, `URLSearchParams.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 => {
+  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 => {
    if (args.length < count) {
      throw typeError(`URLSearchParams.${name} requires ${count} argument${count === 1 ? "" : "s"}.`)
    }
@@ -271,7 +272,17 @@ export const urlSearchParamsGlobal = <R>(ctx: Interpreter<R>) => {
    ],
    ["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").iterator(builtins))],
+    [
+      "entries",
+      0,
+      (thisValue) =>
+        new IteratorObj(
+          builtins.Iterator,
+          self(thisValue, "entries")
+            .params.entries()
+            .map(([key, value]) => wrap([key, value])),
+        ),
+    ],
    ["toString", 0, (thisValue) => self(thisValue, "toString").params.toString()],
    [
      "forEach",
@@ -1,13 +1,64 @@
 import { fn } from "../interpreter/native.js"
 import { typeError } from "../interpreter/model.js"
-import { coerceToNumber, coerceToString, type Native, type Value } from "../interpreter/objects.js"
+import {
+  get,
+  isWrapper,
+  type Native,
+  Arr,
+  Bytes,
+  DateObj,
+  ErrorObj,
+  MapObj,
+  RegExpObj,
+  SetObj,
+  URLObj,
+  URLSearchParamsObj,
+  HeadersObj,
+} 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<Value>): Value => {
+const coerce = <R>(ctx: Interpreter<R>, name: Coercion, args: Array<unknown>): unknown => {
  // 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) {
@@ -15,6 +66,15 @@ const coerce = <R>(ctx: Interpreter<R>, name: Coercion, args: Array<Value>): Val
    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,8 +1,9 @@
 import { fn, methods } from "../interpreter/native.js"
 import { typeError } from "../interpreter/model.js"
-import { Bytes, Obj, coerceToString } from "../interpreter/objects.js"
+import { Bytes, Obj } 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.
@@ -22,16 +22,6 @@ 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(`
@@ -105,24 +95,6 @@ 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(
@@ -135,7 +107,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 23)")
+    expect(failure.message).toBe("RangeError: toFixed() argument must be between 0 and 100 (line 1, col 19)")
  })

  test("a built-in that rejects its arguments before doing any work is located at the call", async () => {
@@ -143,13 +115,13 @@ 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 14)")
-    expect((await error(`return await Promise.race([])`)).message).toEndWith("(line 1, col 14)")
+    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({ [Symbol.iterator]: () => ({ next: 1 }) })`)).message).toEndWith(
-      "(line 1, col 14)",
+      "(line 1, col 10)",
    )
    expect((await error(`let p; p = Promise.resolve().then(() => p); return await p`)).message).toEndWith(
-      "(line 1, col 12)",
+      "(line 1, col 8)",
    )
  })

@@ -162,7 +134,7 @@ describe("host errors escaping built-ins", () => {

  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 8)")
+    expect(failure.message).toBe("TypeError: Iterator next must be a function. (line 1, col 4)")
  })
 })

@@ -181,7 +153,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 18)")
+    expect(failure.message).toBe("RangeError: Maximum call stack size exceeded (line 1, col 14)")
  })

  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("requires an iterable value, received a data object")
+    expect(result.error.message).toContain("or custom iterator value")
  })
 })
@@ -1030,7 +1030,7 @@ describe("confined generators", () => {
        const params = new URLSearchParams(entries())
        return [events, params.toString()]
      `),
-    ).toEqual([["first", "second", "pair close", "outer close"], "%5Bobject+Promise%5D=2"])
+    ).toEqual([["first", "second", "pair close", "outer close"], "%5Bobject+Object%5D=2"])
  })

  test("validates URLSearchParams pair lengths after converting the outer sequence", async () => {
@@ -502,12 +502,6 @@ 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"])
@@ -946,12 +940,6 @@ 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 () => {
@@ -973,17 +961,6 @@ 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(
@@ -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. 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.
+// 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 -> {}.
 const run = (code: string) => Effect.runPromise(CodeMode.execute({ code, tools: {} }))
 const value = async (code: string) => {
  const result = await run(code)
@@ -898,42 +898,6 @@ 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("{}")
@@ -1097,7 +1061,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}', "1,2", "object", true])
+    ).toEqual(["1,2", "1,2", 5, true, true, '{"0":1,"1":2}', "[object Uint8Array]", "object", true])
    expect((await run(`console.log(new Uint8Array([1, 2]), new Uint8Array())`)).logs).toEqual([
      "Uint8Array(2) [1,2] Uint8Array(0) []",
    ])
@@ -1267,75 +1231,6 @@ 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("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(
@@ -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, type Value } from "../../src/interpreter/objects.js"
+import { Callable, define, get, hidden, Arr, Fn, Obj } from "../../src/interpreter/objects.js"
 import { ToolRuntime } from "../../src/tool-runtime.js"

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

-const harness = <R>(ctx: Interpreter<R>, onDone: (error: Value) => void): ReadonlyArray<readonly [string, Value]> => {
+const harness = <R>(
+  ctx: Interpreter<R>,
+  onDone: (error: unknown) => void,
+): ReadonlyArray<readonly [string, unknown]> => {
  const builtins = ctx.builtins
  const test262Prototype = new Obj(builtins.Object)
  define(test262Prototype, "name", "Test262Error", hidden)
@@ -87,7 +90,7 @@ const harness = <R>(ctx: Interpreter<R>, onDone: (error: Value) => void): Readon
  methods(builtins, compareArray, [["format", 1, (_, args) => show(args[0])]])
  const assert = fn<R>(builtins, "assert", 2, (_, args) =>
    args[0] === true
-      ? Effect.undefined
+      ? Effect.void
      : fail(args[1] === undefined ? `Expected true but got ${show(args[0])}` : String(args[1])),
  )
  methods(builtins, assert, [
@@ -96,7 +99,7 @@ const harness = <R>(ctx: Interpreter<R>, onDone: (error: Value) => void): Readon
      3,
      (_, args) =>
        Object.is(args[0], args[1])
-          ? Effect.undefined
+          ? Effect.void
          : fail(`${prefix(args[2])}Expected SameValue(«${show(args[0])}», «${show(args[1])}») to be true`),
    ],
    [
@@ -105,14 +108,14 @@ const harness = <R>(ctx: Interpreter<R>, onDone: (error: Value) => void): Readon
      (_, args) =>
        Object.is(args[0], args[1])
          ? fail(`${prefix(args[2])}Expected SameValue(«${show(args[0])}», «${show(args[1])}») to be false`)
-          : Effect.undefined,
+          : Effect.void,
    ],
    [
      "compareArray",
      3,
      (_, args) =>
        compare(args[0], args[1])
-          ? Effect.undefined
+          ? Effect.void
          : fail(
              `Actual ${show(args[0])} and expected ${show(args[1])} should have the same contents. ${prefix(args[2])}`,
            ),
@@ -129,7 +132,7 @@ const harness = <R>(ctx: Interpreter<R>, onDone: (error: Value) => void): Readon
              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.undefined
+              if (actual === args[0]) return Effect.void
              return fail(`${prefix(args[2])}Expected a ${expected} but got a ${show(actual)}`)
            },
            onSuccess: () =>
@@ -143,13 +146,7 @@ const harness = <R>(ctx: Interpreter<R>, onDone: (error: Value) => void): Readon
    ["assert", assert],
    ["compareArray", compareArray],
    ["Test262Error", test262Error],
-    [
-      "$DONE",
-      fn<R>(builtins, "$DONE", 1, (_, args) => {
-        onDone(args[0])
-        return undefined
-      }),
-    ],
+    ["$DONE", fn<R>(builtins, "$DONE", 1, (_, args) => onDone(args[0]))],
    [
      "$DONOTEVALUATE",
      fn<R>(builtins, "$DONOTEVALUATE", 0, () =>
@@ -225,6 +225,7 @@ 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
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-app",
-  "version": "2.0.11",
+  "version": "2.0.10",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/console-core",
-  "version": "2.0.11",
+  "version": "2.0.10",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-function",
-  "version": "2.0.11",
+  "version": "2.0.10",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-mail",
-  "version": "2.0.11",
+  "version": "2.0.10",
  "dependencies": {
    "@jsx-email/all": "2.2.3",
    "@jsx-email/cli": "1.4.3",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-support",
-  "version": "2.0.11",
+  "version": "2.0.10",
  "type": "module",
  "license": "MIT",
  "scripts": {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
LukeParkerDev	7930c5f676	refactor(app): port the model selection and terminal stores to plain codecs	2026-09-20 16:37:02 +10:00
LukeParkerDev	a440d0bced	refactor(app): port language, drafts, pairing, review panel, open-in-app and upsell stores to plain codecs Also replaces the Effect Iterable pipeline in the provider catalog with array methods.	2026-09-20 16:37:01 +10:00
LukeParkerDev	169ababd60	refactor(app): port command, notification, highlights, home, file-view and workspace-tip stores to plain codecs Session import keeps validating against the shared Effect schema through a dynamic import, so the shared schema and Effect load only when a file is imported. Persisted notification errors are checked structurally instead of through the shared schema. composer/schema.ts carries Effect twins of the file selection shapes until it is ported.	2026-09-20 16:37:00 +10:00
LukeParkerDev	10638d1d9f	refactor(app): port the settings store to plain codecs Migration shapes use preserving structs so undeclared stored fields survive, as Effect's onExcessProperty preserve did at every level; explicit-but-invalid legacy values still decode to null rather than absent; persisted() encodes through encodeOrThrow so an invalid in-memory value fails instead of being written.	2026-09-20 16:37:00 +10:00
LukeParkerDev	faa72aea3a	refactor(app): port the server, model, vcs and project stores to plain codecs Migrations keep their behaviour: URL strings and bare HTTP blocks become server objects, canonical-local project buckets move under local, invalid map entries are dropped individually. Migrated definitions now preserve stored fields the migration does not mention, as Effect's onExcessProperty preserve did. The Effect ServerKey is gone; the codec one in runtime/server/key.ts carries the same brand.	2026-09-20 16:36:59 +10:00
LukeParkerDev	211ce5e9f8	refactor(app): port the layout store to plain codecs Same shapes, defaults and migration as before (workspaces flag to map, review panel flag inherited from the file tree, legacy file-tree width), expressed with the codec module instead of Effect Schema.	2026-09-20 16:36:59 +10:00
LukeParkerDev	3858b11bf9	refactor(app): plain codecs for persisted state, starting with tabs Adds an Effect-free codec module for persisted stores with the same recovery semantics as the Persistence helpers, lets persisted() accept either a Schema or a codec while stores migrate, and ports the tab storage schemas as the first store. ServerKey keeps its brand type on both sides so ServerConnection.Key stays one type. Effect leaves the renderer's initial module graph once the remaining stores are ported.	2026-09-20 16:36:58 +10:00