fix(ai): stop reparsing streamed tool input

2026-09-20 15:47:38 +00:00 · 2026-09-19 04:24:53 +00:00
175 changed files with 897 additions and 3071 deletions
@@ -32,7 +32,7 @@
    },
    "packages/ai": {
      "name": "@opencode/ai",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "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.8",
      "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.8",
      "bin": {
        "opencode2": "./bin/opencode2.cjs",
      },
@@ -175,7 +175,7 @@
    },
    "packages/client": {
      "name": "@opencode/client",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/protocol": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -201,7 +201,7 @@
    },
    "packages/codemode": {
      "name": "@opencode/codemode",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "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.8",
      "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.8",
      "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.8",
      "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.8",
      "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.8",
      "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.8",
      "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.8",
      "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.8",
      "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.8",
      "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.8",
      "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.8",
      "dependencies": {
        "effect": "catalog:",
        "prettier": "3.6.2",
@@ -540,7 +540,7 @@
    },
    "packages/latex": {
      "name": "@opencode/latex",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -554,7 +554,7 @@
    },
    "packages/merman": {
      "name": "@opencode/merman",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -569,7 +569,7 @@
    },
    "packages/plugin": {
      "name": "@opencode/plugin",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "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.8",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -638,7 +638,7 @@
    },
    "packages/protocol": {
      "name": "@opencode/protocol",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/schema": "workspace:*",
        "effect": "catalog:",
@@ -653,7 +653,7 @@
    },
    "packages/schema": {
      "name": "@opencode/schema",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@standard-schema/spec": "catalog:",
        "effect": "catalog:",
@@ -677,7 +677,7 @@
    },
    "packages/sdk": {
      "name": "@opencode/sdk",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -698,7 +698,7 @@
    },
    "packages/server": {
      "name": "@opencode/server",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "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.8",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode/client": "workspace:*",
@@ -755,7 +755,7 @@
    },
    "packages/simulation": {
      "name": "@opencode/simulation",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "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.8",
      "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.8",
      "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.8",
      "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.8",
      "dependencies": {
        "@opentui/core": "catalog:",
        "effect": "catalog:",
@@ -888,7 +888,7 @@
    },
    "packages/tui": {
      "name": "@opencode/tui",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -923,7 +923,7 @@
    },
    "packages/ui": {
      "name": "@opencode/ui",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@pierre/diffs": "catalog:",
@@ -958,7 +958,7 @@
    },
    "packages/util": {
      "name": "@opencode/util",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@effect/opentelemetry": "catalog:",
        "@effect/platform-node": "catalog:",
@@ -991,7 +991,7 @@
    },
    "packages/web": {
      "name": "@opencode/web",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "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.8",
      "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.8",
  "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.8",
  "name": "@opencode/ai",
  "type": "module",
  "license": "MIT",
@@ -73,6 +73,11 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
          )
        if (event.type === "error") {
          terminal = true
+          yield* OpenResponses.decodeKnownErrorEvent(event).pipe(
+            Effect.mapError((cause) =>
+              ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame, cause),
+            ),
+          )
          return {
            type: "provider-failure",
            error: OpenResponses.providerFailure(event, `${options.name} stream error`, frame),
@@ -108,7 +108,7 @@ const incremental = (
  return input.slice(baseline.length)
 }

-const code = (event: OpenResponses.Event) => OpenResponses.errorDetail(event).code
+const code = (event: OpenResponses.Event) => event.code || event.error?.code || event.response?.error?.code || undefined

 const rejected = (
  observation: Extract<ChannelObservation, { readonly type: "provider-failure" }>,
@@ -1,4 +1,4 @@
-import { Effect, Option, Schema } from "effect"
+import { Effect, Option, Schema, SchemaGetter } from "effect"
 import type { Content } from "@opencode/schema/tool"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
@@ -333,13 +333,53 @@ export const StreamItem = Schema.StructWithRest(
 export type StreamItem = Schema.Schema.Type<typeof StreamItem>
 export type OutputItem = StreamItem & { readonly id: string }

-// Responses-compatible providers put error details at the top level, under `error`, or under
-// `response.error`, and gateways reshape them freely: strings, numeric codes, extra fields. Those
-// fields decode as opaque values and `errorDetail` reads them defensively, so an error frame can
-// only fail on invalid JSON and otherwise always classifies with the raw body as the fallback.
+// Responses-compatible providers put streaming error details at the top level or
+// under `error`, and response failures under `response.error`. Accept all three shapes.
 // https://www.openresponses.org/specification
-const asText = (value: unknown) =>
-  typeof value === "string" && value.length > 0 ? value : typeof value === "number" ? String(value) : undefined
+const OpenResponsesErrorObject = Schema.Struct({
+  type: optionalNull(Schema.String),
+  code: optionalNull(Schema.String),
+  message: optionalNull(Schema.String),
+  param: optionalNull(Schema.String),
+})
+const OpenResponsesErrorPayload = Schema.Union([Schema.String, OpenResponsesErrorObject]).pipe(
+  Schema.decodeTo(OpenResponsesErrorObject, {
+    decode: SchemaGetter.transform((error) => (typeof error === "string" ? { message: error } : error)),
+    encode: SchemaGetter.passthrough(),
+  }),
+)
+type OpenResponsesErrorPayload = Schema.Schema.Type<typeof OpenResponsesErrorPayload>
+
+const WebSocketErrorHeader = Schema.Union([Schema.String, Schema.Number, Schema.Boolean])
+export const WebSocketErrorEvent = Schema.StructWithRest(
+  Schema.Struct({
+    type: Schema.tag("error"),
+    status: Schema.optional(Schema.Number),
+    status_code: Schema.optional(Schema.Number),
+    code: optionalNull(Schema.String),
+    message: Schema.optional(Schema.String),
+    param: optionalNull(Schema.String),
+    error: optionalNull(OpenResponsesErrorPayload),
+    headers: Schema.optional(Schema.Record(Schema.String, WebSocketErrorHeader)),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+const decodeWebSocketErrorEvent = Schema.decodeUnknownEffect(WebSocketErrorEvent)
+
+export const decodeKnownErrorEvent = (event: Event) =>
+  decodeWebSocketErrorEvent({
+    ...event,
+    status: typeof event.status === "number" ? event.status : undefined,
+    status_code: typeof event.status_code === "number" ? event.status_code : undefined,
+    headers: ProviderShared.isRecord(event.headers)
+      ? Object.fromEntries(
+          Object.entries(event.headers).filter(
+            (entry): entry is [string, string | number | boolean] =>
+              typeof entry[1] === "string" || typeof entry[1] === "number" || typeof entry[1] === "boolean",
+          ),
+        )
+      : undefined,
+  })

 export const Event = Schema.StructWithRest(
  Schema.Struct({
@@ -360,18 +400,31 @@ export const Event = Schema.StructWithRest(
          incomplete_details: optionalNull(Schema.Struct({ reason: Schema.optional(Schema.String) })),
          output: Schema.optional(Schema.Array(StreamItem)),
          usage: optionalNull(OpenResponsesUsage),
-          error: Schema.optional(Schema.Unknown),
+          error: optionalNull(OpenResponsesErrorPayload),
        }),
        [Schema.Record(Schema.String, Schema.Unknown)],
      ),
    ),
-    code: Schema.optional(Schema.Unknown),
-    message: Schema.optional(Schema.Unknown),
-    error: Schema.optional(Schema.Unknown),
+    code: optionalNull(Schema.String),
+    message: Schema.optional(Schema.String),
+    param: optionalNull(Schema.String),
+    error: optionalNull(OpenResponsesErrorPayload),
    status: Schema.optional(Schema.Unknown),
    status_code: Schema.optional(Schema.Unknown),
+    headers: Schema.optional(Schema.Unknown),
  }),
  [Schema.Record(Schema.String, Schema.Unknown)],
+).pipe(
+  Schema.decode({
+    decode: SchemaGetter.transform((event) => {
+      if (event.type !== "error" || event.error != null) return event
+      const { code, message, param, ...rest } = event
+      if (code === undefined && message === undefined && param === undefined) return event
+      // Flat errors (for example, Meta's) can also arrive through generic Responses endpoints.
+      return { ...rest, error: { code, message, param } }
+    }),
+    encode: SchemaGetter.passthrough(),
+  }),
 )
 export type Event = Schema.Schema.Type<typeof Event>
 export type NormalizedEvent = Event & { readonly item?: OutputItem | null }
@@ -380,15 +433,16 @@ const decodeEventValue = Schema.decodeUnknownEffect(Event)
 const decodeFrame = Schema.decodeUnknownEffect(ProviderShared.Json)

 /**
- * Decodes one WebSocket frame. Some providers and gateways answer a rejected `response.create` with a bare
- * `{ "error": ... }` envelope and no event type; that reads as an error event so it classifies instead of
- * failing decoding.
+ * Decodes one WebSocket frame. xAI answers a rejected `response.create` with `{ "error": { "message", "type" } }` and no
+ * event type; that envelope reads as an error event so the failure classifies instead of failing decoding.
 */
 export const decodeChannelEvent = (frame: string) =>
  decodeFrame(frame).pipe(
    Effect.flatMap((value) =>
      decodeEventValue(
-        ProviderShared.isRecord(value) && value.type === undefined && value.error != null
+        ProviderShared.isRecord(value) &&
+          value.type === undefined &&
+          (typeof value.error === "string" || ProviderShared.isRecord(value.error))
          ? { ...value, type: "error" }
          : value,
      ),
@@ -1368,21 +1422,22 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
  return [{ ...current, lifecycle }, events] satisfies StepResult
 })

-/** Error code and message from wherever the frame put them; top-level fields win over nested ones. */
-export const errorDetail = (event: Event) => {
-  const raw = event.error ?? event.response?.error
-  const nested = typeof raw === "string" ? { message: raw } : ProviderShared.isRecord(raw) ? raw : undefined
-  return {
-    message: asText(event.message) ?? asText(nested?.message),
-    code: asText(event.code) ?? asText(nested?.code),
-  }
+// Build the prettiest summary available from whatever the provider supplied.
+// When both code and message are present, prefix the code so consumers see
+// the failure mode (e.g. `rate_limit_exceeded: Slow down`) instead of just
+// the bare message — production rate limits and context-length failures used
+// to be indistinguishable from generic stream drops. Returns undefined when
+// the payload carries no usable summary.
+const providerErrorMessage = (event: Event, nested: OpenResponsesErrorPayload | undefined): string | undefined => {
+  const message = event.message || nested?.message || undefined
+  const code = event.code || nested?.code || undefined
+  if (message && code) return `${code}: ${message}`
+  return message || code
 }

-// Prefix the code when both are present (`rate_limit_exceeded: Slow down`) so the failure mode is
-// visible; fall back to the raw frame rather than a generic message when neither decodes.
 export const providerFailure = (event: Event, fallback: string, body = ProviderShared.encodeJson(event)) => {
-  const detail = errorDetail(event)
-  const summary = detail.message && detail.code ? `${detail.code}: ${detail.message}` : (detail.message ?? detail.code)
+  const nested = event.error ?? event.response?.error ?? undefined
+  const summary = providerErrorMessage(event, nested)
  const message = summary ?? (body === "{}" ? fallback : body)
  const status =
    typeof event.status === "number"
@@ -1465,7 +1520,18 @@ export const step = (state: ParserState, event: NormalizedEvent) => {
  if (event.type === "response.output_item.done") return onOutputItemDone(state, event.item)
  if (event.type === "response.completed" || event.type === "response.incomplete") return onResponseFinish(state, event)
  if (event.type === "response.failed") return providerFailure(event, `${state.name} response failed`)
-  if (event.type === "error") return providerFailure(event, `${state.name} stream error`)
+  if (event.type === "error")
+    return decodeKnownErrorEvent(event).pipe(
+      Effect.mapError((cause) =>
+        ProviderShared.eventError(
+          state.id,
+          `${state.name} returned a malformed error event`,
+          ProviderShared.encodeJson(event),
+          cause,
+        ),
+      ),
+      Effect.flatMap(() => providerFailure(event, `${state.name} stream error`)),
+    )
  return Effect.succeed<StepResult>([state, NO_EVENTS])
 }

@@ -66,7 +66,6 @@ const inputDelta = (tool: PendingTool, text: string) =>
    name: tool.name,
    namespace: tool.namespace,
    text,
-    input: Option.getOrElse(parsePartialInput(tool.input), () => ({})),
  })

 const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
@@ -215,9 +215,7 @@ export const fromWebSocket = (
 ): Effect.Effect<WebSocketConnection, AIError> =>
  Effect.gen(function* () {
    yield* waitOpen(ws, input)
-    // The socket pushes frames synchronously and cannot be paused, so the hand-off to the consumer
-    // fiber must absorb whole read buffers. Bun delivers over a thousand small frames in one tick.
-    const messages = yield* Queue.unbounded<string | Uint8Array, AIError | Cause.Done<void>>()
+    const messages = yield* Queue.bounded<string | Uint8Array, AIError | Cause.Done<void>>(128)

    const oversized = (message: string | Uint8Array) =>
      typeof message === "string" ? new Blob([message]).size > MAX_FRAME_BYTES : message.byteLength > MAX_FRAME_BYTES
@@ -240,7 +238,19 @@ export const fromWebSocket = (
    }
    const offer = (message: string | Uint8Array) => {
      if (rejectOversized(message)) return
-      Queue.offerUnsafe(messages, message)
+      if (Queue.offerUnsafe(messages, message)) return
+      Queue.failCauseUnsafe(
+        messages,
+        Cause.fail(
+          transportError("WebSocket inbound queue overflow", {
+            body: typeof message === "string" ? message : new TextDecoder().decode(message),
+            url: input.url,
+            operation: "read",
+            code: "queue-overflow",
+            phase: "receive",
+          }),
+        ),
+      )
    }

    const onMessage = (event: MessageEvent) => {
@@ -182,7 +182,7 @@ export const ToolInputDelta = Schema.Struct({
  name: Schema.String,
  namespace: Schema.optional(Schema.String),
  text: Schema.String,
-  /** Best-effort parse of all input fragments received through this delta. */
+  /** Optional best-effort parse supplied by adapters; native routes emit raw text until the final tool call. */
  input: Schema.optional(Schema.Unknown),
 }).annotate({ identifier: "LLM.Event.ToolInputDelta" })
 export type ToolInputDelta = Schema.Schema.Type<typeof ToolInputDelta>
@@ -1680,13 +1680,12 @@ describe("Anthropic Messages route", () => {
      expect(response.events).toEqual([
        { type: "step-start", index: 0 },
        { type: "tool-input-start", id: "call_1", name: "lookup" },
-        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"', input: {} },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"' },
        {
          type: "tool-input-delta",
          id: "call_1",
          name: "lookup",
          text: ':"weather"}',
-          input: { query: "weather" },
        },
        { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata: undefined },
        {
@@ -822,13 +822,12 @@ describe("Bedrock Converse route", () => {
      ])
      const events = response.events.filter((event) => event.type === "tool-input-delta")
      expect(events).toEqual([
-        { type: "tool-input-delta", id: "tool_1", name: "lookup", text: '{"query"', input: {} },
+        { type: "tool-input-delta", id: "tool_1", name: "lookup", text: '{"query"' },
        {
          type: "tool-input-delta",
          id: "tool_1",
          name: "lookup",
          text: ':"weather"}',
-          input: { query: "weather" },
        },
      ])
      expect(response.events.at(-1)).toMatchObject({
@@ -916,7 +915,6 @@ describe("Bedrock Converse route", () => {
          id: "tool_1",
          name: "lookup",
          text: '{"query":"weather"}',
-          input: { query: "weather" },
        },
      ])
    }),
@@ -413,14 +413,12 @@ describe("Mistral Chat", () => {
          id: "Ab12Cd34E",
          name: "lookup",
          text: '{"city":',
-          input: {},
        },
        {
          type: "tool-input-delta",
          id: "Ab12Cd34E",
          name: "lookup",
          text: '"Paris"}',
-          input: { city: "Paris" },
        },
        { type: "tool-input-end", id: "Ab12Cd34E", name: "lookup", providerMetadata: undefined },
        {
@@ -11,78 +11,66 @@ import { sseEvents } from "../lib/sse.js"

 const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)

-it.effect("decodes error frames verbatim in shared SSE and WebSocket decoding", () =>
+it.effect("normalizes flat errors in shared SSE and WebSocket decoding", () =>
  Effect.gen(function* () {
+    const frame = {
+      type: "error",
+      sequence_number: 4,
+      code: "server_shutting_down",
+      message: "Server is shutting down. Please retry your request.",
+      param: null,
+    }
    for (const decode of [decodeEvent, OpenResponses.decodeChannelEvent]) {
-      for (const frame of [
-        { type: "error", sequence_number: 4, code: "server_shutting_down", message: "Shutting down", param: null },
+      const event = yield* decode(JSON.stringify(frame))
+      expect(event).toEqual({
+        type: "error",
+        sequence_number: 4,
+        error: { code: frame.code, message: frame.message, param: null },
+      })
+
+      for (const unchanged of [
+        event,
        { type: "error" },
-        { type: "error", error: "Gateway failed" },
-        { type: "error", error: { code: 429, message: "slow down" } },
-        { type: "error", error: 42 },
-        { type: "error", code: 500, message: ["not", "a", "string"] },
-        { type: "response.failed", response: { id: "resp_failed", error: "Gateway failed" } },
-        { type: "response.failed", response: { id: "resp_failed", error: ["weird"] } },
        {
          type: "response.failed",
          response: { id: "resp_failed", error: { code: "server_error", message: "Internal server error" } },
        },
        { type: "response.output_text.delta", item_id: "msg_text", delta: "Hello" },
      ]) {
-        expect(yield* decode(JSON.stringify(frame))).toEqual(frame)
+        expect(yield* decode(JSON.stringify(unchanged))).toEqual(unchanged)
      }
    }
  }),
 )

-it.effect("reads bare WebSocket error envelopes as error events", () =>
+it.effect("continues to normalize untyped xAI WebSocket errors", () =>
  Effect.gen(function* () {
    const message = "gRPC error: Response with id=resp_missing not found"
-    for (const error of [{ type: "api_error", message }, message, 42]) {
-      expect(yield* OpenResponses.decodeChannelEvent(JSON.stringify({ error }))).toEqual({ type: "error", error })
-    }
-    for (const frame of [{ error: null }, { message }]) {
-      expect(yield* OpenResponses.decodeChannelEvent(JSON.stringify(frame)).pipe(Effect.flip)).toBeDefined()
+    for (const error of [{ type: "api_error", message }, message]) {
+      expect(yield* OpenResponses.decodeChannelEvent(JSON.stringify({ error }))).toEqual({
+        type: "error",
+        error: typeof error === "string" ? { message } : error,
+      })
    }
  }),
 )

-it.effect("extracts error details from every shape and falls back to the raw frame", () =>
+it.effect("normalizes string errors in shared SSE and WebSocket decoding", () =>
  Effect.gen(function* () {
-    const cases: Array<[frame: Record<string, unknown>, message: string, tag: string]> = [
-      [
-        { type: "error", code: "server_shutting_down", message: "Shutting down" },
-        "server_shutting_down: Shutting down",
-        "UnknownProvider",
-      ],
-      [{ type: "error", error: "Gateway failed" }, "Gateway failed", "UnknownProvider"],
-      [{ type: "error", error: { code: 429, message: "slow down" } }, "429: slow down", "UnknownProvider"],
-      [{ type: "error", error: { message: "slow down" }, status: 429 }, "slow down", "RateLimit"],
-      [{ type: "error", code: 500, message: ["not", "a", "string"] }, "500", "UnknownProvider"],
-      [
-        { type: "response.failed", response: { id: "resp_failed", error: "Gateway failed" } },
-        "Gateway failed",
-        "UnknownProvider",
-      ],
-    ]
-    for (const [frame, message, tag] of cases) {
-      const event = yield* OpenResponses.decodeChannelEvent(JSON.stringify(frame))
-      const error = OpenResponses.providerFailure(event, "fallback", JSON.stringify(frame))
-      expect(error.message).toBe(message)
-      expect(error.reason._tag).toBe(tag)
-      expect(error.reason.body).toBe(JSON.stringify(frame))
+    for (const decode of [decodeEvent, OpenResponses.decodeChannelEvent]) {
+      expect(yield* decode(JSON.stringify({ type: "error", error: "Gateway failed" }))).toEqual({
+        type: "error",
+        error: { message: "Gateway failed" },
+      })
+      expect(
+        yield* decode(
+          JSON.stringify({ type: "response.failed", response: { id: "resp_failed", error: "Gateway failed" } }),
+        ),
+      ).toEqual({
+        type: "response.failed",
+        response: { id: "resp_failed", error: { message: "Gateway failed" } },
+      })
    }
-    for (const frame of [
-      { type: "error", error: 42 },
-      { type: "response.failed", response: { id: "resp_failed", error: ["weird"] } },
-    ]) {
-      const event = yield* OpenResponses.decodeChannelEvent(JSON.stringify(frame))
-      const error = OpenResponses.providerFailure(event, "fallback", JSON.stringify(frame))
-      expect(error.message).toBe(JSON.stringify(frame))
-      expect(error.reason._tag).toBe("UnknownProvider")
-    }
-    expect(OpenResponses.providerFailure({ type: "error" }, "fallback", "{}").message).toBe("fallback")
-    expect(OpenResponses.providerFailure({ type: "error" }, "fallback", "{}").reason._tag).toBe("ProviderInternal")
  }),
 )

@@ -313,7 +313,6 @@ describe("Open Responses basic-item lifecycles", () => {
          id: "call_bc1eb4b42e70ee53",
          name: "get_weather",
          text: '{\n  "city": "Paris"\n}',
-          input: { city: "Paris" },
        },
        { type: "tool-input-end", id: "call_bc1eb4b42e70ee53", name: "get_weather", providerMetadata },
        {
@@ -1511,13 +1511,12 @@ describe("OpenAI Chat route", () => {
      expect(response.events).toEqual([
        { type: "step-start", index: 0 },
        { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata: undefined },
-        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"', input: {} },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"' },
        {
          type: "tool-input-delta",
          id: "call_1",
          name: "lookup",
          text: ':"weather"}',
-          input: { query: "weather" },
        },
        { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata: undefined },
        {
@@ -1568,7 +1567,6 @@ describe("OpenAI Chat route", () => {
          id: "call_1",
          name: "lookup",
          text: '{"query":"weather"',
-          input: { query: "weather" },
        },
        {
          type: "step-finish",
@@ -1624,7 +1622,6 @@ describe("OpenAI Chat route", () => {
          id: "call_1",
          name: "lookup",
          text: '{"query":"weather"}',
-          input: { query: "weather" },
        },
        {
          type: "step-finish",
@@ -1690,7 +1687,6 @@ describe("OpenAI Chat route", () => {
          id: "call_1",
          name: "lookup",
          text: '{"query":"weather"',
-          input: { query: "weather" },
        },
      ])
    }),
@@ -1780,13 +1776,12 @@ describe("OpenAI Chat route", () => {
      expect(response.events).toEqual([
        { type: "step-start", index: 0 },
        { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata: undefined },
-        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"', input: {} },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"' },
        {
          type: "tool-input-delta",
          id: "call_1",
          name: "lookup",
          text: ':"weather"}',
-          input: { query: "weather" },
        },
        { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata: undefined },
        {
@@ -4038,14 +4038,12 @@ describe("OpenAI Responses route", () => {
          id: "call_1",
          name: "lookup",
          text: '{"query"',
-          input: {},
        },
        {
          type: "tool-input-delta",
          id: "call_1",
          name: "lookup",
          text: ':"weather"}',
-          input: { query: "weather" },
        },
        {
          type: "tool-input-end",
@@ -4117,8 +4115,8 @@ describe("OpenAI Responses route", () => {
      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))

      expect(response.events.filter((event) => event.type === "tool-input-delta")).toEqual([
-        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"', input: {} },
-        { type: "tool-input-delta", id: "call_1", name: "lookup", text: ':"weather"}', input: { query: "weather" } },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"' },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: ':"weather"}' },
      ])
      expect(response.events.filter(LLMEvent.is.toolInputEnd)).toHaveLength(1)
      expect(response.events.filter(LLMEvent.is.toolCall)).toEqual([
@@ -4156,7 +4154,6 @@ describe("OpenAI Responses route", () => {
          id: "call_1",
          name: "lookup",
          text: '{"query":"weather"}',
-          input: { query: "weather" },
        },
      ])
      expect(response.events.find(LLMEvent.is.toolCall)).toMatchObject({ input: { query: "weather" } })
@@ -4217,7 +4214,6 @@ describe("OpenAI Responses route", () => {
          id: "call_1",
          name: "lookup",
          text: '{"query":"streamed"}',
-          input: { query: "streamed" },
        },
      ])
      expect(response.events.find(LLMEvent.is.toolCall)).toMatchObject({ input: { query: "final" } })
@@ -23,11 +23,9 @@ describe("ToolStream", () => {

      expect(first.events).toEqual([
        { type: "tool-input-start", id: "call_1", name: "lookup" },
-        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"', input: {} },
-      ])
-      expect(second.events).toEqual([
-        { type: "tool-input-delta", id: "call_1", name: "lookup", text: ':"weather"}', input: { query: "weather" } },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"' },
      ])
+      expect(second.events).toEqual([{ type: "tool-input-delta", id: "call_1", name: "lookup", text: ':"weather"}' }])
      expect(finished).toEqual({
        tools: {},
        events: [
@@ -38,7 +36,7 @@ describe("ToolStream", () => {
    }),
  )

-  test("exposes cumulative partial string values", () => {
+  test("streams raw deltas without reparsing cumulative input", () => {
    const result = ToolStream.appendOrStart(
      ADAPTER,
      ToolStream.empty<number>(),
@@ -53,26 +51,9 @@ describe("ToolStream", () => {
      id: "call_1",
      name: "lookup",
      text: '{"query":"wea',
-      input: { query: "wea" },
    })
  })

-  test("defaults partial input to an empty object when the accumulated value cannot be parsed", () => {
-    const result = ToolStream.appendOrStart(
-      ADAPTER,
-      ToolStream.empty<number>(),
-      0,
-      { id: "call_1", name: "lookup", text: "x" },
-      "missing tool",
-    )
-    if (ToolStream.isError(result)) throw result
-
-    expect(result.events).toEqual([
-      { type: "tool-input-start", id: "call_1", name: "lookup" },
-      { type: "tool-input-delta", id: "call_1", name: "lookup", text: "x", input: {} },
-    ])
-  })
-
  it.effect("keeps accumulated identity when later deltas contain empty strings", () =>
    Effect.gen(function* () {
      const first = ToolStream.appendOrStart(
@@ -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,110 +0,0 @@
-import { expect, test, type Locator, type Page } from "@playwright/test"
-import { fixture, pageMessages } from "../smoke/session-timeline.fixture"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-test.use({ viewport: { width: 390, height: 844 }, hasTouch: true, isMobile: true })
-
-test.beforeEach(async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    sessions: fixture.sessions,
-    provider: fixture.provider,
-    directory: fixture.directory,
-    project: fixture.project,
-    pageMessages,
-  })
-  await page.addInitScript(
-    ({ directory, server, sessions }) => {
-      localStorage.setItem(
-        "opencode.global.dat:server",
-        JSON.stringify({ projects: { local: [{ worktree: directory, expanded: true }] } }),
-      )
-      localStorage.setItem(
-        "opencode.window.browser.dat:tabs",
-        JSON.stringify(sessions.map((session) => ({ type: "session", server, sessionId: session.id }))),
-      )
-    },
-    { directory: fixture.directory, server: fixture.serverKey, sessions: fixture.sessions },
-  )
-  await page.goto("/")
-  await page.locator('[data-slot="mobile-tabs-trigger"]').click()
-  await expect(page.locator('[data-slot="mobile-tabs-drawer"]')).toBeVisible()
-  const drawer = page.locator('[data-slot="mobile-drawer-content"]')
-  await expect
-    .poll(() => drawer.evaluate((element) => new DOMMatrixReadOnly(getComputedStyle(element).transform).m42))
-    .toBe(0)
-  await expect(drawer).not.toHaveAttribute("data-transitioning")
-})
-
-test("reorders session tabs with touch", async ({ page }) => {
-  const tabs = page.locator('[data-slot="vertical-tabs"] a')
-  await expect(tabs).toContainText([fixture.expected.sourceTitle, fixture.expected.targetTitle])
-
-  const target = tabs.filter({ hasText: fixture.expected.targetTitle })
-  const source = tabs.filter({ hasText: fixture.expected.sourceTitle })
-  const targetBox = await target.boundingBox()
-  const sourceBox = await source.boundingBox()
-  expect(targetBox).not.toBeNull()
-  expect(sourceBox).not.toBeNull()
-
-  await touchDrag(page, source, {
-    from: { x: sourceBox!.x + sourceBox!.width / 2, y: sourceBox!.y + sourceBox!.height / 2 },
-    to: { x: targetBox!.x + targetBox!.width / 2, y: targetBox!.y + targetBox!.height / 2 },
-  })
-
-  await expect(tabs).toContainText([fixture.expected.targetTitle, fixture.expected.sourceTitle])
-})
-
-test("dismisses a touch context menu by tapping outside", async ({ page }) => {
-  const drawer = page.locator('[data-slot="mobile-tabs-drawer"]')
-  const tab = drawer.locator('[data-slot="tab-link"]').filter({ hasText: fixture.expected.sourceTitle })
-  const home = drawer.getByRole("button", { name: "Home", exact: true })
-  const homeBox = await home.boundingBox()
-  const box = await tab.boundingBox()
-  expect(homeBox).not.toBeNull()
-  expect(box).not.toBeNull()
-  const point = { x: box!.x + box!.width / 2, y: box!.y + box!.height / 2 }
-
-  await tab.dispatchEvent("pointerdown", {
-    pointerType: "touch",
-    pointerId: 1,
-    isPrimary: true,
-    clientX: point.x,
-    clientY: point.y,
-  })
-  const rename = page.getByRole("menuitem", { name: "Rename", exact: true })
-  await expect(rename).toBeVisible()
-  await expect(drawer).toBeVisible()
-  await tab.filter({ visible: true }).dispatchEvent("pointerup", {
-    pointerType: "touch",
-    pointerId: 1,
-    isPrimary: true,
-    clientX: point.x,
-    clientY: point.y,
-  })
-
-  await page.touchscreen.tap(homeBox!.x + homeBox!.width / 2, homeBox!.y + homeBox!.height / 2)
-  await expect(rename).toBeHidden()
-  await expect(drawer).toBeVisible()
-})
-
-async function touchDrag(
-  page: Page,
-  source: Locator,
-  input: { from: { x: number; y: number }; to: { x: number; y: number } },
-) {
-  const client = await page.context().newCDPSession(page)
-  await client.send("Input.dispatchTouchEvent", {
-    type: "touchStart",
-    touchPoints: [{ ...input.from, id: 1 }],
-  })
-  await client.send("Input.dispatchTouchEvent", {
-    type: "touchMove",
-    touchPoints: [{ x: (input.from.x + input.to.x) / 2, y: (input.from.y + input.to.y) / 2, id: 1 }],
-  })
-  await expect(source).toHaveCount(2)
-  await client.send("Input.dispatchTouchEvent", {
-    type: "touchMove",
-    touchPoints: [{ ...input.to, id: 1 }],
-  })
-  await client.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] })
-}
@@ -166,45 +166,6 @@ test.describe("session timeline projection", () => {
    await expect(longNotice.locator("[title]")).toHaveAttribute("title", `Switched to ${longName}`)
    await expect.poll(() => longNotice.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true)
  })
-
-  test("does not repeat a review comment file as an attachment", async ({ page }) => {
-    const message = userMessage([
-      userText("what's goin on here", { id: "prt_user_review_comment" }),
-      {
-        id: "prt_user_review_file",
-        type: "file",
-        mime: "text/plain",
-        filename: "LiveRuntime.ts",
-        url: "file:///repo/LiveRuntime.ts?start=14&end=32",
-      },
-      {
-        id: "prt_user_unrelated_file",
-        type: "file",
-        mime: "text/plain",
-        filename: "notes.txt",
-        url: "data:text/plain;base64,bm90ZXM=",
-      },
-    ])
-    message.metadata = {
-      displayText: "what's goin on here",
-      comments: [
-        {
-          path: "LiveRuntime.ts",
-          comment: "what's goin on here",
-          selection: { startLine: 14, startChar: 0, endLine: 32, endChar: 0 },
-          origin: "review",
-        },
-      ],
-    }
-
-    await setupTimeline(page, { messages: [message, assistantMessage()] })
-
-    const user = page.locator('[data-component="user-message"]')
-    await expect(user.getByText("LiveRuntime.ts:14-32", { exact: true })).toBeVisible()
-    const attachments = user.locator('[data-slot="user-message-attachments"]')
-    await expect(attachments.getByText("LiveRuntime.ts", { exact: true })).toHaveCount(0)
-    await expect(attachments.getByText("notes.txt", { exact: true })).toBeVisible()
-  })
 })

 function patchFile(file: string, status: "added" | "modified" | "deleted") {
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/app",
-  "version": "2.0.11",
+  "version": "2.0.8",
  "description": "",
  "type": "module",
  "exports": {
@@ -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));
      }
    }
  }
@@ -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",
@@ -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,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>
@@ -1,8 +1,7 @@
-import { For, Show, createEffect, createMemo, on, onCleanup } from "solid-js"
+import { For, Show, createEffect, createMemo, lazy, on, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { Button } from "@opencode/ui/button"
-import { Icon } from "@opencode/ui/icon"
 import { IconButton } from "@opencode/ui/icon-button"
 import { TextInput } from "@opencode/ui/text-input"
 import { showToast } from "@/shell/notifications/toast"
@@ -18,6 +17,8 @@ import { useLanguage } from "@/runtime/i18n/language"
 import { useSettings } from "@/settings/model"
 import { SettingsList } from "@/settings/list"

+const Icon = lazy(() => import("@opencode/ui/icon").then((module) => ({ default: module.Icon })))
+
 const IS_MAC = typeof navigator === "object" && /(Mac|iPod|iPhone|iPad)/.test(navigator.platform)
 const PALETTE_ID = "command.palette"

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { canOpenTabRename, forwardTabRef, isTabCloseTarget } from "./tab-gesture"
+import { canOpenTabRename, canStartTabDrag, forwardTabRef, isTabCloseTarget } from "./tab-gesture"

 describe("titlebar tab gestures", () => {
  test("excludes close controls from tab gestures", () => {
@@ -24,4 +24,10 @@ describe("titlebar tab gestures", () => {
    expect(canOpenTabRename(false, false, false)).toBe(true)
    expect(canOpenTabRename(false, false, true)).toBe(false)
  })
+
+  test("preserves native panning for touch pointers", () => {
+    expect(canStartTabDrag("mouse")).toBe(true)
+    expect(canStartTabDrag("pen")).toBe(true)
+    expect(canStartTabDrag("touch")).toBe(false)
+  })
 })
@@ -4,6 +4,10 @@ export function isTabCloseTarget(target: EventTarget | null) {
  return target instanceof Element && !!target.closest('[data-slot="tab-close"]')
 }

+export function canStartTabDrag(pointerType: string) {
+  return pointerType !== "touch"
+}
+
 export function forwardTabRef(ref: Ref<HTMLDivElement> | undefined, element: HTMLDivElement) {
  if (typeof ref === "function") ref(element)
 }
@@ -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);
 }
@@ -328,7 +328,6 @@ export function TabNavItem(props: {

  return (
    <Menu.Context
-      modal={false}
      onOpenChange={(open) => {
        setMenu("open", open)
        if (open) setPopoverOpen(false)
@@ -16,7 +16,7 @@ import { useTabs } from "@/shell/tabs/tabs"
 import { createTabComposerState } from "@/composer/persistence"
 import { base64Encode } from "@opencode/util/encode"
 import { showToast } from "@/shell/notifications/toast"
-import { isTabCloseTarget } from "./tab-gesture"
+import { canStartTabDrag, isTabCloseTarget } from "./tab-gesture"
 import { adjacentTabKey, mergeVisibleTabOrder } from "./tab-order"
 import type { SessionInfo } from "@opencode/client/promise"

@@ -292,11 +292,9 @@ export function TitlebarTabStrip(props: {
        <DragDropProvider
          sensors={[
            PointerSensor.configure({
-              activationConstraints: (event) =>
-                event.pointerType === "touch"
-                  ? [new PointerActivationConstraints.Distance({ value: 8 })]
-                  : [new PointerActivationConstraints.Distance({ value: 4 })],
+              activationConstraints: [new PointerActivationConstraints.Distance({ value: 4 })],
              preventActivation: (event) =>
+                !canStartTabDrag(event.pointerType) ||
                isTabCloseTarget(event.target) ||
                (event.target instanceof Element && !!event.target.closest('[contenteditable="true"]')),
            }),
@@ -315,7 +313,6 @@ export function TitlebarTabStrip(props: {
            if (!source) return
            const tab = props.tabs.find((item) => tabKey(item) === source.id.toString())
            if (!tab) return
-            if (vertical()) return
            const tabEl = source.element?.querySelector<HTMLDivElement>("[data-titlebar-tab]")
            props.onNavigate(tab, tabEl ?? undefined)
          }}
@@ -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,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/cli",
-  "version": "2.0.11",
+  "version": "2.0.8",
  "type": "module",
  "license": "MIT",
  "bin": {
@@ -1,120 +0,0 @@
-#!/usr/bin/env bun
-import { Script } from "@opencode/script"
-import { $ } from "bun"
-import { mkdir, rm } from "node:fs/promises"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-import { UpdateArtifact } from "../../../script/update-artifact"
-
-if (Script.channel !== "beta" && Script.channel !== "latest") {
-  throw new Error("Homebrew publishing requires the beta or latest channel")
-}
-const valid =
-  Script.channel === "beta"
-    ? /^\d+\.\d+\.\d+-beta[.-]\d+(?:\.\d+)?$/.test(Script.version)
-    : /^\d+\.\d+\.\d+$/.test(Script.version)
-if (!valid) throw new Error(`Expected a ${Script.channel} release version`)
-
-const dir = fileURLToPath(new URL("..", import.meta.url))
-const root = path.resolve(process.env.OPENCODE_CLI_DIST ?? path.join(dir, "dist"))
-const outdir = path.join(root, "homebrew-tap")
-const dryRun = process.argv.includes("--dry-run")
-const name = Script.channel === "beta" ? "opencode-beta" : "opencode-v2"
-const formulaClass = Script.channel === "beta" ? "OpencodeBeta" : "OpencodeV2"
-
-const targets = await Promise.all(
-  [
-    { name: "darwin-arm64", archive: "zip" },
-    { name: "darwin-x64-baseline", archive: "zip" },
-    { name: "linux-arm64", archive: "tar.gz" },
-    { name: "linux-x64-baseline", archive: "tar.gz" },
-  ].map(async (target) => {
-    const filename = `opencode-${target.name}.${target.archive}`
-    const file = Bun.file(path.join(root, filename))
-    if (!(await file.exists()) || !file.size) throw new Error(`Missing Homebrew archive: ${filename}`)
-    const sha256 = new Bun.CryptoHasher("sha256")
-    for await (const chunk of file.stream()) sha256.update(chunk)
-    return {
-      ...target,
-      url: `https://opencode.ai/files/bin/${encodeURIComponent(Script.version)}/${filename}`,
-      sha256: sha256.digest("hex"),
-    }
-  }),
-)
-
-await rm(outdir, { recursive: true, force: true })
-if (dryRun) await mkdir(outdir, { recursive: true })
-if (!dryRun) {
-  const token = process.env.GITHUB_TOKEN
-  if (!token) throw new Error("GITHUB_TOKEN is required to update the Homebrew tap")
-  await $`git clone ${`https://x-access-token:${token}@github.com/anomalyco/homebrew-tap.git`} ${outdir}`
-  await $`git checkout -B master`.cwd(outdir)
-}
-
-const target = (name: string) => {
-  const result = targets.find((item) => item.name === name)
-  if (!result) throw new Error(`Missing Homebrew target: ${name}`)
-  return result
-}
-const macArm = target("darwin-arm64")
-const macIntel = target("darwin-x64-baseline")
-const linuxArm = target("linux-arm64")
-const linuxIntel = target("linux-x64-baseline")
-
-await Bun.write(
-  path.join(outdir, `${name}.rb`),
-  [
-    "# typed: false",
-    "# frozen_string_literal: true",
-    "",
-    `class ${formulaClass} < Formula`,
-    `  desc "OpenCode V2${Script.channel === "beta" ? " beta" : ""} - the AI coding agent for the terminal"`,
-    '  homepage "https://github.com/anomalyco/opencode"',
-    `  version "${Script.version}"`,
-    '  license "MIT"',
-    "",
-    '  depends_on "ripgrep"',
-    '  conflicts_with "opencode", because: "both install an opencode binary"',
-    "",
-    "  on_macos do",
-    "    if Hardware::CPU.arm?",
-    `      url "${macArm.url}"`,
-    `      sha256 "${macArm.sha256}"`,
-    "    else",
-    `      url "${macIntel.url}"`,
-    `      sha256 "${macIntel.sha256}"`,
-    "    end",
-    "  end",
-    "",
-    "  on_linux do",
-    "    if Hardware::CPU.arm?",
-    `      url "${linuxArm.url}"`,
-    `      sha256 "${linuxArm.sha256}"`,
-    "    else",
-    `      url "${linuxIntel.url}"`,
-    `      sha256 "${linuxIntel.sha256}"`,
-    "    end",
-    "  end",
-    "",
-    "  def install",
-    '    bin.install "opencode"',
-    "  end",
-    "end",
-    "",
-  ].join("\n"),
-)
-console.log(`Prepared ${name} ${Script.version} in ${outdir}`)
-if (dryRun) process.exit(0)
-
-await $`git add ${name + ".rb"}`.cwd(outdir)
-if ((await $`git diff --cached --quiet`.cwd(outdir).nothrow()).exitCode !== 0) {
-  await $`git commit -m ${`chore: update ${name} to ${Script.version}`}`.cwd(outdir)
-  await $`git push origin master`.cwd(outdir)
-}
-await UpdateArtifact.publish({
-  channel: Script.channel,
-  name: "cli",
-  distribution: "homebrew",
-  version: Script.version,
-  metadata: { package: `anomalyco/tap/${name}` },
-})
@@ -149,10 +149,6 @@ if (Script.channel === "latest" && Script.release && !dryRun) {

 if ((Script.channel === "beta" || Script.channel === "latest") && Script.release) {
  await $`bun ./script/publish-aur.ts ${dryRun ? ["--dry-run"] : []}`.env({ ...process.env, OPENCODE_CLI_DIST: root })
-  await $`bun ./script/publish-homebrew.ts ${dryRun ? ["--dry-run"] : []}`.env({
-    ...process.env,
-    OPENCODE_CLI_DIST: root,
-  })
 }

 async function archive(bin: string, target: string, binary: string, directory: string) {
@@ -1,22 +1,17 @@
 import { Global } from "@opencode/util/global"
 import { AppProcess } from "@opencode/util/process"
 import { OPENCODE_ARTIFACT, OPENCODE_CHANNEL, OPENCODE_LOCAL, OPENCODE_VERSION } from "../version"
-import { Context, Duration, Effect, FileSystem, Layer, Option, Ref, Schema } from "effect"
+import { Context, Duration, Effect, FileSystem, Layer, Ref } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { parse, type ParseError } from "jsonc-parser"
 import path from "node:path"
 import { action, parseReleaseVersion, type Policy } from "./updater-action"

-export const methods = ["curl", "npm", "pnpm", "bun", "yarn", "vp", "brew"] as const
-
+export const methods = ["curl", "npm", "pnpm", "bun", "yarn"] as const
 export type Method = (typeof methods)[number]
 export type RunResult = { readonly type: "available" | "installed"; readonly version: string }
 export type CheckResult = RunResult | { readonly type: "unavailable"; readonly message: string }

-const decodeVpPackages = Schema.decodeUnknownOption(
-  Schema.fromJsonString(Schema.Array(Schema.Struct({ name: Schema.String }))),
-)
-
 export interface Interface {
  readonly run: (onInstall?: (version: string) => void) => Effect.Effect<RunResult | undefined>
  readonly check: () => Effect.Effect<CheckResult | undefined, Error>
@@ -101,13 +96,6 @@ const make = Effect.gen(function* () {
      process.platform === "win32" ? "opencode.exe" : "opencode",
    )
    if (path.resolve(process.execPath) === path.resolve(binary)) return "curl"
-    const executable = yield* fs.realPath(process.execPath).pipe(Effect.orElseSucceed(() => process.execPath))
-    if (
-      ["opencode-beta", "opencode-v2"].some((name) =>
-        executable.includes(`${path.sep}Cellar${path.sep}${name}${path.sep}`),
-      )
-    )
-      return "brew"
    if (!installedPackage) return

    const checks: ReadonlyArray<{ method: Method; command: string[] }> = [
@@ -115,30 +103,22 @@ const make = Effect.gen(function* () {
      { method: "pnpm", command: ["pnpm", "list", "-g", "--depth=0", installedPackage] },
      { method: "bun", command: ["bun", "pm", "ls", "-g"] },
      { method: "yarn", command: ["yarn", "global", "list"] },
-      { method: "vp", command: ["vp", "list", "-g", "--json", installedPackage] },
    ]
    const results = yield* Effect.forEach(
      checks,
      (check) => exec(check.command).pipe(Effect.map((result) => ({ check, result }))),
      { concurrency: "unbounded" },
    )
-    return results.find((result) => {
-      if (result.check.method !== "vp") return result.result.stdout.includes(installedPackage)
-      // Vite+ repeats the filter in its successful no-match message, so substring detection would be a false positive.
-      return Option.exists(decodeVpPackages(result.result.stdout), (packages) =>
-        packages.some((item) => item.name === installedPackage),
-      )
-    })?.check.method
+    return results.find((result) => result.result.stdout.includes(installedPackage))?.check.method
  })

  const removal = (method: Method) => {
-    if (method === "curl" || method === "brew" || !installedPackage) return undefined
+    if (method === "curl" || !installedPackage) return undefined
    const commands = {
      npm: ["npm", "uninstall", "--global", installedPackage],
      pnpm: ["pnpm", "remove", "--global", installedPackage],
      bun: ["bun", "remove", "--global", installedPackage],
      yarn: ["yarn", "global", "remove", installedPackage],
-      vp: ["vp", "uninstall", "-g", installedPackage],
    }
    const command = commands[method]
    return {
@@ -153,12 +133,11 @@ const make = Effect.gen(function* () {
    }
  }

-  const release = Effect.fnUntraced(function* (method?: Method) {
-    const distribution = method === "brew" ? "homebrew" : "npm"
+  const release = Effect.fnUntraced(function* () {
    const response = yield* Effect.tryPromise({
      try: (signal) =>
        fetch(
-          `https://opencode.ai/update/api/${encodeURIComponent(channel)}/${encodeURIComponent(OPENCODE_ARTIFACT)}/${distribution}?current=${encodeURIComponent(OPENCODE_VERSION)}`,
+          `https://opencode.ai/update/api/${encodeURIComponent(channel)}/${encodeURIComponent(OPENCODE_ARTIFACT)}/npm?current=${encodeURIComponent(OPENCODE_VERSION)}`,
          {
            signal: AbortSignal.any([signal, AbortSignal.timeout(10_000)]),
          },
@@ -174,11 +153,7 @@ const make = Effect.gen(function* () {
    return { package: data.metadata.package, version: data.version }
  })

-  const latest = () =>
-    method().pipe(
-      Effect.flatMap(release),
-      Effect.map((data) => data.version),
-    )
+  const latest = () => release().pipe(Effect.map((data) => data.version))

  const temporaryDirectory = (prefix: string) =>
    Effect.acquireRelease(fs.makeTempDirectory({ directory: global.cache, prefix }), (directory) =>
@@ -188,12 +163,12 @@ const make = Effect.gen(function* () {
  const upgrade = Effect.fnUntraced(function* (method: Method, input: string) {
    if (!parseReleaseVersion(input)) return yield* Effect.fail(new Error(`Invalid version: ${input}`))
    const version = input.trim().replace(/^v/, "")
-    const packageName = (yield* release(method)).package
+    const packageName = (yield* release()).package
    const target = `${packageName}@${version}`
    if (installedPackage && packageName !== installedPackage && (method === "pnpm" || method === "yarn")) {
      return yield* Effect.fail(new Error(`Reinstall ${target} with ${method} to migrate from ${installedPackage}.`))
    }
-    const commands: Record<Exclude<Method, "bun" | "curl" | "brew">, string[]> = {
+    const commands: Record<Exclude<Method, "bun" | "curl">, string[]> = {
      // Keep the old package: uninstalling it can unlink the replacement command.
      npm: [
        "npm",
@@ -207,10 +182,6 @@ const make = Effect.gen(function* () {
      ],
      pnpm: ["pnpm", "add", "--global", `--allow-build=${packageName}`, target],
      yarn: ["yarn", "global", "add", target],
-      vp:
-        installedPackage && packageName !== installedPackage
-          ? ["vp", "install", "-g", "--force", target]
-          : ["vp", "update", "-g", target],
    }
    const result = yield* Effect.scoped(
      Effect.gen(function* () {
@@ -231,7 +202,6 @@ const make = Effect.gen(function* () {
          if (download.code !== 0) return download
          return yield* exec(["bash", installer, "--version", version, "--no-modify-path"], "5 minutes")
        }
-        if (method === "brew") return yield* exec(["brew", "upgrade", packageName], "5 minutes")
        return yield* exec(commands[method], "5 minutes")
      }),
    ).pipe(Effect.mapError((cause) => new Error(`Failed to update with ${method}`, { cause })))
@@ -19,7 +19,6 @@ function fixture(
  } = () => ({}),
  name = "@opencode/cli",
  failCleanup = false,
-  releasePackage = name,
 ) {
  return Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem
@@ -35,7 +34,7 @@ function fixture(
    yield* Effect.acquireRelease(
      Effect.sync(() =>
        spyOn(globalThis, "fetch").mockImplementation(
-          Object.assign(async () => Response.json({ version: "2.3.4", metadata: { package: releasePackage } }), {
+          Object.assign(async () => Response.json({ version: "2.3.4", metadata: { package: name } }), {
            preconnect: fetch.preconnect,
          }),
        ),
@@ -107,7 +106,6 @@ const installs = [
    command: ["pnpm", "add", "--global", "--allow-build=@opencode/cli", "@opencode/cli@2.3.4-beta.1"],
  },
  { method: "yarn", command: ["yarn", "global", "add", "@opencode/cli@2.3.4-beta.1"] },
-  { method: "vp", command: ["vp", "update", "-g", "@opencode/cli@2.3.4-beta.1"] },
 ] as const

 installs.forEach(({ method, command }) => {
@@ -119,25 +117,6 @@ installs.forEach(({ method, command }) => {
    }),
  )
 })
-
-it.live("vp force-installs a renamed V2 package that replaces the existing binary owner", () =>
-  Effect.gen(function* () {
-    const test = yield* fixture(() => ({}), "@opencode/cli", false, "@opencode/cli-node")
-    yield* test.updater.upgrade("vp", "v2.3.4-beta.1")
-    expect(test.commands).toEqual([["vp", "install", "-g", "--force", "@opencode/cli-node@2.3.4-beta.1"]])
-  }),
-)
-
-it.live("vp removes the package from its managed global store", () =>
-  Effect.gen(function* () {
-    const test = yield* fixture()
-    const removal = test.updater.removal("vp")
-    if (!removal) return yield* Effect.die("Expected vp removal command")
-    expect(removal.command).toEqual(["vp", "uninstall", "-g", "@opencode/cli"])
-    yield* removal.run
-    expect(test.commands).toEqual([["vp", "uninstall", "-g", "@opencode/cli"]])
-  }),
-)
 ;[0, 1].forEach((exitCode) => {
  it.live(`bun isolates and removes its install cache after exit ${exitCode}`, () =>
    Effect.gen(function* () {
@@ -221,19 +200,11 @@ it.live("install failures expose stderr and process errors do not report success
    expect(missing.commands).toHaveLength(1)
  }),
 )
-;(["npm", "pnpm", "bun", "yarn", "vp", undefined] as const).forEach((method) => {
+;(["npm", "pnpm", "bun", "yarn", undefined] as const).forEach((method) => {
  it.live(`method detection identifies ${method ?? "an unknown installation"} using the V2 package`, () =>
    Effect.gen(function* () {
      const test = yield* fixture((command) => ({
-        stdout: Buffer.from(
-          command.command === method
-            ? method === "vp"
-              ? JSON.stringify([{ name: "@opencode/cli", version: "2.3.4" }])
-              : "@opencode/cli@2.3.4"
-            : command.command === "vp"
-              ? "[]"
-              : "opencode-ai@1.0.0",
-        ),
+        stdout: Buffer.from(command.command === method ? "@opencode/cli@2.3.4" : "opencode-ai@1.0.0"),
      }))
      expect(yield* test.updater.method()).toBe(method)
      expect(test.commands).toEqual([
@@ -241,7 +212,6 @@ it.live("install failures expose stderr and process errors do not report success
        ["pnpm", "list", "-g", "--depth=0", "@opencode/cli"],
        ["bun", "pm", "ls", "-g"],
        ["yarn", "global", "list"],
-        ["vp", "list", "-g", "--json", "@opencode/cli"],
      ])
    }),
  )
@@ -255,16 +225,7 @@ it.live("method detection tolerates unavailable package managers", () =>
        : { error: new AppProcess.AppProcessError({ command: command.command }) },
    )
    expect(yield* test.updater.method()).toBe("yarn")
-    expect(test.commands).toHaveLength(5)
-  }),
-)
-
-it.live("vp detection ignores no-match output that repeats the package name", () =>
-  Effect.gen(function* () {
-    const test = yield* fixture((command) => ({
-      stdout: Buffer.from(command.command === "vp" ? "No global packages matching '@opencode/cli'." : ""),
-    }))
-    expect(yield* test.updater.method()).toBeUndefined()
+    expect(test.commands).toHaveLength(4)
  }),
 )

@@ -304,16 +265,13 @@ if (typeof OPENCODE_CLI_NAME === "string" && OPENCODE_CLI_NAME === "opencode2-no
      expect(yield* test.updater.method()).toBe("npm")
      yield* test.updater.upgrade("npm", "v2.3.4")
      yield* test.updater.upgrade("pnpm", "v2.3.4")
-      yield* test.updater.upgrade("vp", "v2.3.4")
      expect(test.commands).toEqual([
        ["npm", "list", "-g", "--depth=0", "@opencode/cli-node"],
        ["pnpm", "list", "-g", "--depth=0", "@opencode/cli-node"],
        ["bun", "pm", "ls", "-g"],
        ["yarn", "global", "list"],
-        ["vp", "list", "-g", "--json", "@opencode/cli-node"],
        ["npm", "install", "--global", "@opencode/cli-node@2.3.4"],
        ["pnpm", "add", "--global", "--allow-build=@opencode/cli-node", "@opencode/cli-node@2.3.4"],
-        ["vp", "update", "-g", "@opencode/cli-node@2.3.4"],
      ])
    }),
  )
@@ -35,12 +35,6 @@ describe("upgrade command", () => {
    expect(result.events).toEqual([{ method: "bun", version: "2.0.0" }])
  })

-  test("accepts vp as an explicit installation method", async () => {
-    const result = await cli(["2.0.0", "--method", "vp"])
-    expect(result.exitCode).toBe(0)
-    expect(result.events).toEqual([{ method: "vp", version: "2.0.0" }])
-  })
-
  test("skips the already installed version", async () => {
    const result = await cli(["v0.0.0-beta-old"])
    expect(result.exitCode).toBe(0)
@@ -56,7 +50,7 @@ describe("upgrade command", () => {
  })

  test("rejects unsupported methods before attempting an upgrade", async () => {
-    const result = await cli(["--method", "apt"])
+    const result = await cli(["--method", "brew"])
    expect(result.exitCode).not.toBe(0)
    expect(result.events).toEqual([])
  })
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/client",
-  "version": "2.0.11",
+  "version": "2.0.8",
  "type": "module",
  "license": "MIT",
  "repository": {
@@ -13,8 +13,8 @@ The idea of code mode was originally introduced by Cloudflare. See

 ## How it differs from JavaScript

- **Only supported APIs are available.** Programs can use the provided tools, supported JavaScript built-ins, and the
-  globals the host adds through extensions. Timers, `process`, filesystem access, imports, and modules are unavailable.
+- **Only supported APIs are available.** Programs can use the provided tools and supported JavaScript built-ins. APIs
+  such as `fetch`, timers, `process`, filesystem access, imports, and modules are unavailable.
 - **Unfinished work is interrupted.** Tool calls and async functions start when called. When the program finishes,
  anything still running is interrupted. Unhandled rejections from un-awaited promises are returned as warnings.
 - **REPL-style results.** Without an explicit `return`, the final top-level expression becomes the result. `undefined`
@@ -94,19 +94,11 @@ receive `{ extension, name, args }`. An `after` hook also receives how the call
 `failure` with its error, or `interrupted`). A failing `before` hook denies the call, and the program catches the
 failure as a thrown error.

-### `Extension.make`
+### `Values`

-Extensions are host functions a program calls directly as globals, such as `fetch`. Unlike tools they are not in the
-catalog, not counted against `maxToolCalls`, and not described to the model; the host decides what they mean.
-
-```ts
-const web = Extension.make({ name: "web", globals: { fetch: (url: string) => globalThis.fetch(url) } })
-const runtime = CodeMode.make({ tools, extensions: [web] })
-```
-
-Every value crossing in either direction is converted, never shared: arguments come in as copies, results go out as
-copies, and a function inside a result is callable the same way. A global that shadows a built-in or another
-extension throws at `CodeMode.make`.
+`Values` exports the runtime's non-JSON value classes: `Values.URL`, `Values.URLSearchParams`, `Values.Date`,
+`Values.RegExp`, `Values.Map`, `Values.Set`, and `Values.Promise`. The interpreter recognizes these by class; a
+program's `new URL(...)` is a `Values.URL` wrapping the host `URL`. `Values.isValue` narrows to the data-like kinds.

 ### OpenAPI tools

@@ -28,7 +28,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      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 `{}`.
- [x] Live Date, RegExp, Map, Set, URL, URLSearchParams, Headers, and Uint8Array values inside CodeMode.
+- [x] Live Date, RegExp, Map, Set, URL, URLSearchParams, and Uint8Array values inside CodeMode.
 - [x] Tool calls through the host-provided `tools` tree only.
 - [x] The global `search(...)` built-in: synchronous tool discovery that counts as an admitted tool call and is
      shadowable by program declarations like other globals.
@@ -44,8 +44,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 ## Values and literals

 - [x] `null`, `undefined`, booleans, finite and non-finite numbers, and strings.
- [x] Array literals, including holes and spread from arrays, strings, Maps, Sets, URLSearchParams, Headers, custom
-      synchronous iterators, and synchronous generators.
+- [x] Array literals, including holes and spread from arrays, strings, Maps, Sets, URLSearchParams, custom synchronous
+      iterators, and synchronous generators.
 - [x] Object literals with shorthand, computed string/number keys, and spread following ToObject: data objects and
      arrays copy own enumerable keys, strings copy index keys, and other values contribute nothing.
 - [x] Template literals with interpolation.
@@ -53,7 +53,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] `NaN` and `Infinity` globals.
 - [ ] BigInt literals and in-interpreter BigInt arithmetic; BigInt remains invalid at JSON-like host boundaries.
 - [ ] Arbitrary Symbol primitive values and symbol-keyed properties. The confined `Symbol.iterator` and
-      `Symbol.asyncIterator` keys are available only for the iterator protocols.
+      `Symbol.asyncIterator` keys are available only for custom iterator protocols.
 - [ ] Tagged-template calls.
 - [ ] Getter and setter definitions in object literals.

@@ -92,8 +92,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] `if`/`else` and conditional expressions.
 - [x] `switch`, including default clauses and fallthrough.
 - [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...of` over arrays, strings, Maps, Sets, URLSearchParams, custom synchronous iterators, and confined
+      synchronous generators. Abrupt completion invokes the iterator's optional `return()`.
 - [x] `for...in` over own keys of plain objects, arrays, strings, and tool references; other values iterate nothing.
 - [x] Unlabeled `break` and `continue`.
 - [x] `try`, `catch`, optional catch bindings, and `finally`.
@@ -124,7 +124,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      string). A detached method loses its receiver, as in JS: `values.filter("abc".includes)` is a `TypeError`
      because `includes` is called without a string `this`.
 - [x] Constructors work as callbacks with JS call semantics: `Error` types construct (`messages.map(Error)`),
-      and new-requiring constructors (`Map`, `Set`, `URL`, `URLSearchParams`, `Headers`, `Promise`) throw a `TypeError`,
+      and new-requiring constructors (`Map`, `Set`, `URL`, `URLSearchParams`, `Promise`) throw a `TypeError`,
      like JS.
 - [x] Tool references and detached `Promise` statics are rejected as callbacks with a hint to wrap them in an
      arrow function.
@@ -176,10 +176,10 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Sequence expressions (the comma operator).
 - [x] `await` for CodeMode promises and callable thenables; a plain value passes through unchanged, though every
      `await` still defers its continuation one reaction turn.
- [x] `new` for Array, Object, Error types, Date, RegExp, Map, Set, URL, URLSearchParams, Headers, and Promise. `new`
-      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
+- [x] `new` for Array, Object, Error types, Date, RegExp, Map, Set, URL, URLSearchParams, and Promise. `new` 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.
 - [x] Arithmetic operators: `+`, `-`, `*`, `/`, `%`, and `**`.
 - [x] Equality and ordering: `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, and `>=`.
@@ -287,10 +287,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Ordering: `sort`, `toSorted`, `reverse`, and `toReversed`.
 - [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, which is only observable through `getPrototypeOf`.
+- [x] Materialized iteration helpers: `keys`, `values`, and `entries` return arrays rather than iterators.
 - [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`.
@@ -305,6 +302,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      separator: JavaScript applies ToIntegerOrInfinity/ToString (including `valueOf`, strings, and `undefined`), the
      interpreter requires numbers and strings; `includes()`/`indexOf()` with no argument should search for
      `undefined`.
+- [ ] Iterator objects from `keys`, `values`, and `entries` with a live `next()`.

 ## Strings

@@ -316,7 +314,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Regular-expression integration: `match`, materialized `matchAll`, `replace`, `replaceAll`, `split`, and `search`.
 - [x] `localeCompare`; locale and options arguments are currently ignored.
 - [x] `isWellFormed` and `toWellFormed`.
- [x] `toString`, `length`, numeric indexing, spread, `for...of`, and `[Symbol.iterator]` by Unicode code point.
+- [x] `toString`, `length`, numeric indexing, spread, and `for...of` by Unicode code point.
 - [x] Static `String.fromCharCode` and `String.fromCodePoint`.
 - [x] Native argument coercion for supported String methods; for example, `includes(1)` and `slice("1")` coerce like
      native JS, `split(undefined)` returns the whole string, and `includes`/`startsWith`/`endsWith` reject regular
@@ -407,8 +405,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [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()`
-      may return a built-in iterator or an array.
+- [x] Materialized `keys`, `values`, and `entries` arrays for Map and Set.
 - [x] Spread, `for...of`, `Array.from`, and `Object.fromEntries` integration.
 - [x] Map and Set values serialize to `{}` at host/JSON boundaries.
 - [x] Set composition and relation methods: `union`, `intersection`, `difference`, `symmetricDifference`, `isSubsetOf`,
@@ -424,7 +421,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Writable URL fields except `origin`.
 - [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`.
+      `entries`, `toString`, and `size`.
 - [x] URL values serialize to their href; URLSearchParams serialize to `{}`.

 ## Uint8Array
@@ -437,8 +434,7 @@ with a hint to encode as text first (`TextDecoder`, `toBase64`, `toHex`).
 - [x] Index reads and writes with JS byte semantics: values wrap modulo 256, out-of-range writes are ignored, indexes
      cannot be deleted. `length` is a prototype accessor, so `Object.keys` lists only indexes.
 - [x] `at`, `slice`, `subarray` (a view on the same bytes), `set`, `fill`, `reverse`, `indexOf`, `lastIndexOf`,
-      `includes`, `join`, `toString`, `toBase64`, `toHex`, and live `keys`, `values`, `entries`, and `[Symbol.iterator]`
-      iterators.
+      `includes`, `join`, `toString`, `toBase64`, `toHex`, and materialized `keys`, `values`, and `entries` arrays.
 - [x] Spread, destructuring, `for...of`, `yield*`, `Array.from`, and `new Set(bytes)`. `Array.isArray` is false.
 - [x] String coercion joins with commas; `JSON.stringify` gives `{"0":1,...}`; `console.log` prints
      `Uint8Array(n) [...]`.
@@ -452,13 +448,7 @@ with a hint to encode as text first (`TextDecoder`, `toBase64`, `toHex`).
 - [x] `crypto.randomUUID()` and `crypto.getRandomValues(uint8Array)`.
 - [x] `TextEncoder` and `TextDecoder` for UTF-8 only: any other label is a `RangeError`. `TextDecoder` accepts the
      `fatal` and `ignoreBOM` options; `decode` takes a Uint8Array or nothing.
- [x] `new Headers()` from records, synchronous iterables of pairs, and Headers, wrapping the host's `Headers`: names
-      fold to lowercase, values are normalized and combined, and invalid names or values throw a `TypeError`.
- [x] Headers `append`, `delete`, `get`, `getSetCookie`, `has`, `set`, `forEach`, `keys`, `values`, `entries`, and
-      `[Symbol.iterator]`; iteration is live and sorted by name, with `set-cookie` values kept apart.
- [x] Headers serialize to a `{ name: value }` object in JSON, in results, and in tool arguments.
- [ ] `Request`, `Response`, and `Blob`.
- [ ] `crypto.subtle` and `TextDecoder` streaming or non-UTF-8 encodings.
+- [ ] `crypto.subtle`, `Blob`, and `TextDecoder` streaming or non-UTF-8 encodings.

 ## Extensions

@@ -468,8 +458,8 @@ Nothing is exposed unless a host provides it; extension calls are not tool calls
 - [x] Each global is a function, callable but not constructible, run with `this` undefined. A global that shadows
      a built-in or another extension throws at `make`.
 - [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),
+      `Date`, `RegExp`, `URL`, `URLSearchParams`, `Map`, `Set`, and `Uint8Array` become fresh copies with their
+      contents converted (a host `ArrayBuffer` comes in as a `Uint8Array`; other typed arrays cannot come out),
      errors cross as errors with their name and message, and a `__proto__` key is dropped. Functions, generators,
      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
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/codemode",
-  "version": "2.0.11",
+  "version": "2.0.8",
  "description": "Effect-native confined code execution over schema-described tools",
  "type": "module",
  "license": "MIT",
@@ -17,7 +17,6 @@ import {
  record,
  SetObj,
  URLSearchParamsObj,
-  HeadersObj,
 } from "./interpreter/objects.js"
 import { typeofValue } from "./interpreter/references.js"

@@ -70,7 +69,6 @@ const walk = <R>(
        )
      }
      if (boundary && value instanceof URLSearchParamsObj) return value.params.toString()
-      if (value instanceof HeadersObj) return Object.fromEntries(value.headers)
      const target = boundary && value instanceof SetObj ? new Arr(ctx.builtins.Array, [...value.set]) : value
      if (stack.has(target)) throw typeError("Converting circular structure to JSON.")
      stack.add(target)
@@ -20,7 +20,6 @@ import {
  DateObj,
  ErrorObj,
  GeneratorObj,
-  IteratorObj,
  MapObj,
  Obj,
  PromiseObj,
@@ -28,7 +27,6 @@ import {
  SetObj,
  URLObj,
  URLSearchParamsObj,
-  HeadersObj,
 } from "./objects.js"
 import { describeValue } from "./references.js"

@@ -54,7 +52,6 @@ export const extensionGlobals = <R>(
    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))
@@ -62,7 +59,6 @@ export const extensionGlobals = <R>(
      !(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.`)
@@ -129,7 +125,6 @@ export const extensionGlobals = <R>(
      if (value instanceof URLSearchParams) {
        return new URLSearchParamsObj(builtins.URLSearchParams, new URLSearchParams(value))
      }
-      if (value instanceof Headers) return new HeadersObj(builtins.Headers, new Headers(value))
      if (value instanceof Map) {
        const wrapped = new MapObj(builtins.Map)
        for (const [key, item] of value) wrapped.map.set(next(key, label), next(item, label))
@@ -11,8 +11,6 @@ import { objectGlobal } from "../stdlib/object.js"
 import { regexpGlobal } from "../stdlib/regexp.js"
 import { stringGlobal } from "../stdlib/string.js"
 import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js"
-import { headersGlobal } from "../stdlib/headers.js"
-import { iteratorGlobals } from "../stdlib/iterator.js"
 import { coercion } from "../stdlib/value.js"
 import { base64Global, cryptoGlobal } from "../stdlib/web.js"
 import { ToolReference } from "../tool-runtime.js"
@@ -82,7 +80,6 @@ const table: Record<string, Factory> = {
  Set: (ctx) => setGlobal(ctx),
  URL: (ctx) => urlGlobal(ctx),
  URLSearchParams: (ctx) => urlSearchParamsGlobal(ctx),
-  Headers: (ctx) => headersGlobal(ctx),
  Uint8Array: (ctx) => uint8ArrayGlobal(ctx),
  TextEncoder: (ctx) => textEncoderGlobal(ctx),
  TextDecoder: (ctx) => textDecoderGlobal(ctx),
@@ -102,6 +99,5 @@ export const globalNames: ReadonlySet<string> = new Set(Object.keys(table))
 /** The immutable global bindings of every program, in declaration order. */
 export const globals = <R>(ctx: Interpreter<R>): ReadonlyArray<readonly [string, unknown]> => {
  generatorGlobals(ctx)
-  iteratorGlobals(ctx)
  return Object.entries(table).map(([name, factory]) => [name, factory(ctx)] as const)
 }
@@ -79,13 +79,11 @@ import {
  DateObj,
  Fn,
  GeneratorObj,
-  IteratorObj,
  MapObj,
  Obj,
  PromiseObj,
  SetObj,
  URLSearchParamsObj,
-  HeadersObj,
  record,
  remove,
  set,
@@ -651,11 +649,11 @@ class Frame<R> {
      if (declared?.lexical) self.predeclarePattern(declared.pattern, declared.mutable, left)
      const right = yield* self.evaluateExpression(node.right)

-      const cursor = self.hostCursor(right)
-      const iterator = cursor === undefined ? yield* self.customIterator(right, node, awaiting) : undefined
+      const iterator = yield* self.customIterator(right, node, awaiting)
+      const cursor = iterator === undefined ? yield* self.iterate(right, node) : undefined
      if (iterator === undefined && cursor === undefined) {
        throw invalidData(
-          `${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, URLSearchParams, or Headers, or custom iterator value.`,
+          `${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, or URLSearchParams, or custom iterator value.`,
          node,
        )
      }
@@ -747,20 +745,6 @@ class Frame<R> {
  }

  iterate(value: unknown, node?: AstNode) {
-    const cursor = this.hostCursor(value)
-    if (cursor !== undefined) return Effect.succeed(cursor)
-    const self = this
-    return Effect.map(this.customIterator(value, node, false), (iterator) =>
-      iterator === undefined
-        ? undefined
-        : {
-            next: self.nextIteratorResult(iterator, node, false),
-            close: Effect.suspend(() => self.closeIterator(iterator, node, false)),
-          },
-    )
-  }
-
-  private hostCursor(value: unknown) {
    const iterator =
      value instanceof Arr
        ? value.items[Symbol.iterator]()
@@ -772,25 +756,31 @@ class Frame<R> {
              ? 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: Array.isArray(step.value) ? new Arr(proto, step.value) : step.value,
-        }
-      }),
-      close: Effect.void,
+                : value instanceof Bytes
+                  ? value.bytes.values()
+                  : undefined
+    if (iterator !== undefined) {
+      const proto = this.ctx.builtins.Array
+      return Effect.succeed({
+        next: Effect.sync(() => {
+          const step = iterator.next()
+          return {
+            done: Boolean(step.done),
+            value: Array.isArray(step.value) ? new Arr(proto, step.value) : step.value,
+          }
+        }),
+        close: Effect.void,
+      })
    }
+    const self = this
+    return Effect.map(this.customIterator(value, node, false), (iterator) =>
+      iterator === undefined
+        ? undefined
+        : {
+            next: self.nextIteratorResult(iterator, node, false),
+            close: Effect.suspend(() => self.closeIterator(iterator, node, false)),
+          },
+    )
  }

  private customIterator(value: unknown, node: AstNode | undefined, allowAsync = true) {
@@ -1858,7 +1848,6 @@ class Frame<R> {
        value instanceof MapObj ||
        value instanceof SetObj ||
        value instanceof URLSearchParamsObj ||
-        value instanceof HeadersObj ||
        value instanceof Bytes
      ) {
        const cursor = yield* self.iterate(value, node)
@@ -29,7 +29,6 @@ const builtins = [
  "Set",
  "URL",
  "URLSearchParams",
-  "Headers",
  "Uint8Array",
  "TextEncoder",
  "TextDecoder",
@@ -81,7 +80,6 @@ export const createBuiltins = (): Builtins => {
    Set: plain(),
    URL: plain(),
    URLSearchParams: plain(),
-    Headers: plain(),
    Uint8Array: plain(),
    TextEncoder: plain(),
    TextDecoder: plain(),
@@ -122,16 +122,6 @@ export class GeneratorObj extends Obj {
  }
 }

-/** A built-in collection iterator: live over the host collection, yielding program values. */
-export class IteratorObj extends Obj {
-  constructor(
-    proto: Obj,
-    readonly iterator: IteratorObject<unknown>,
-  ) {
-    super(proto)
-  }
-}
-
 export class DateObj extends Obj {
  constructor(
    proto: Obj,
@@ -166,15 +156,6 @@ export class URLSearchParamsObj extends Obj {
  }
 }

-export class HeadersObj extends Obj {
-  constructor(
-    proto: Obj,
-    readonly headers: Headers,
-  ) {
-    super(proto)
-  }
-}
-
 export class URLObj extends Obj {
  readonly searchParams: URLSearchParamsObj
  constructor(
@@ -200,14 +181,13 @@ export class Bytes extends Obj {
 /** 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 is DateObj | RegExpObj | MapObj | SetObj | URLObj | URLSearchParamsObj | 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
@@ -9,7 +9,6 @@ import {
  Bytes,
  DateObj,
  GeneratorObj,
-  IteratorObj,
  MapObj,
  Obj,
  PromiseObj,
@@ -17,14 +16,12 @@ import {
  SetObj,
  URLObj,
  URLSearchParamsObj,
-  HeadersObj,
 } from "./objects.js"

 /** Values that cannot cross the data boundary. */
 export const isRuntimeReference = (value: unknown): boolean =>
  value instanceof Callable ||
  value instanceof GeneratorObj ||
-  value instanceof IteratorObj ||
  value instanceof ToolReference ||
  value instanceof PromiseObj ||
  isWrapper(value)
@@ -88,10 +85,8 @@ export const describeValue = (value: unknown): string => {
  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}`
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
 import { constructor, type Method, methods, prototypeFrom, receiver } from "../interpreter/native.js"
 import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interpreter/limits.js"
-import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js"
-import { define, get, hidden, Arr, GeneratorObj, IteratorObj, Obj } from "../interpreter/objects.js"
+import { invalidData, rangeError, typeError } from "../interpreter/model.js"
+import { get, Arr, GeneratorObj, Obj } from "../interpreter/objects.js"
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js"
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
@@ -340,18 +340,13 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
        return target
      },
    ],
-    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").items.keys())],
-    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").items.values())],
+    ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").items.keys()))],
+    ["values", 0, (thisValue) => wrap([...self(thisValue, "values").items])],
    [
      "entries",
      0,
      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
-          self(thisValue, "entries")
-            .items.entries()
-            .map(([index, item]) => wrap([index, item])),
-        ),
+        wrap(Array.from(self(thisValue, "entries").items.entries(), ([index, item]) => wrap([index, item]))),
    ],
    iterate("map", 1, (target, receiver, apply) =>
      Effect.gen(function* () {
@@ -495,6 +490,5 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
      }),
    ),
  ])
-  define(proto, IteratorSymbol, get(proto, "values"), hidden)
  return array
 }
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js"
 import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js"
-import { IteratorSymbol, rangeError, syntaxError, typeError } from "../interpreter/model.js"
-import { define, defineAccessor, get, hidden, Arr, Bytes, IteratorObj, Obj } from "../interpreter/objects.js"
+import { rangeError, syntaxError, typeError } from "../interpreter/model.js"
+import { defineAccessor, get, Arr, Bytes, Obj } from "../interpreter/objects.js"
 import { describeValue } from "../interpreter/references.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
 import { coerceToNumber, coerceToString } from "./value.js"
@@ -173,21 +173,15 @@ export const uint8ArrayGlobal = <R>(ctx: Interpreter<R>) => {
    ["toString", 0, (thisValue) => self(thisValue, "toString").bytes.join(",")],
    ["toBase64", 0, (thisValue) => self(thisValue, "toBase64").bytes.toBase64()],
    ["toHex", 0, (thisValue) => self(thisValue, "toHex").bytes.toHex()],
-    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").bytes.keys())],
-    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").bytes.values())],
+    ["keys", 0, (thisValue) => wrapAll(Array.from(self(thisValue, "keys").bytes.keys()))],
+    ["values", 0, (thisValue) => wrapAll(Array.from(self(thisValue, "values").bytes.values()))],
    [
      "entries",
      0,
      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
-          self(thisValue, "entries")
-            .bytes.entries()
-            .map(([index, byte]) => wrapAll([index, byte])),
-        ),
+        wrapAll(Array.from(self(thisValue, "entries").bytes.entries(), ([index, byte]) => wrapAll([index, byte]))),
    ],
  ])
-  define(proto, IteratorSymbol, get(proto, "values"), hidden)
  return uint8Array
 }

@@ -1,6 +1,6 @@
 import { Effect } from "effect"
 import { constructor, fn, type Method, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js"
-import { invalidData, IteratorSymbol, typeError } from "../interpreter/model.js"
+import { invalidData, typeError } from "../interpreter/model.js"
 import {
  define,
  defineAccessor,
@@ -9,7 +9,6 @@ import {
  hidden,
  isWrapper,
  Arr,
-  IteratorObj,
  MapObj,
  Obj,
  PromiseObj,
@@ -154,18 +153,12 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {
        return undefined
      },
    ],
-    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").map.keys())],
-    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").map.values())],
+    ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").map.keys()))],
+    ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").map.values()))],
    [
      "entries",
      0,
-      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
-          self(thisValue, "entries")
-            .map.entries()
-            .map(([key, item]) => wrap([key, item])),
-        ),
+      (thisValue) => wrap(Array.from(self(thisValue, "entries").map.entries(), ([key, item]) => wrap([key, item]))),
    ],
    [
      "forEach",
@@ -180,7 +173,6 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {
      },
    ],
  ])
-  define(proto, IteratorSymbol, get(proto, "entries"), hidden)
  return map
 }

@@ -226,8 +218,7 @@ const loadSetRecord = <R>(
      size: Math.max(Math.trunc(size), 0),
      has: (item: unknown) => Effect.map(ctx.call(has, source, [item]), Boolean),
      keys: () =>
-        Effect.flatMap(ctx.call(keys, source, []), (result): Effect.Effect<Iterable<unknown>> => {
-          if (result instanceof IteratorObj) return Effect.succeed(result.iterator)
+        Effect.flatMap(ctx.call(keys, source, []), (result) => {
          if (result instanceof Arr) return Effect.succeed(result.items)
          throw typeError(`Set.${name} expected 'keys' to return an iterator.`)
        }),
@@ -347,18 +338,12 @@ export const setGlobal = <R>(ctx: Interpreter<R>) => {
        return undefined
      },
    ],
-    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").set.values())],
-    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").set.values())],
+    ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").set.values()))],
+    ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").set.values()))],
    [
      "entries",
      0,
-      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
-          self(thisValue, "entries")
-            .set.values()
-            .map((item) => wrap([item, item])),
-        ),
+      (thisValue) => wrap(Array.from(self(thisValue, "entries").set.values(), (item) => wrap([item, item]))),
    ],
    [
      "forEach",
@@ -380,6 +365,5 @@ export const setGlobal = <R>(ctx: Interpreter<R>) => {
    operation("isSupersetOf"),
    operation("isDisjointFrom"),
  ])
-  define(proto, IteratorSymbol, get(proto, "values"), hidden)
  return set
 }
@@ -12,7 +12,6 @@ import {
  SetObj,
  URLObj,
  URLSearchParamsObj,
-  HeadersObj,
 } from "../interpreter/objects.js"
 import { containsOpaqueReference, isRuntimeReference } from "../interpreter/references.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
@@ -67,7 +66,6 @@ const formatConsoleValue = (value: unknown, seen: Set<object>, depth: number): s
  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]"
@@ -1,132 +0,0 @@
-import { Effect } from "effect"
-import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js"
-import { IteratorSymbol, typeError } from "../interpreter/model.js"
-import { define, entries, get, hidden, Arr, HeadersObj, IteratorObj, Obj } from "../interpreter/objects.js"
-import { 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.
-const attempt = <T>(run: () => T): T => {
-  try {
-    return run()
-  } catch (error) {
-    throw typeError(error instanceof Error ? error.message : String(error))
-  }
-}
-
-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* () {
-    const pairs = init instanceof Obj ? yield* readPairs(ctx, init, "new Headers(...)") : undefined
-    if (pairs !== undefined) return wrap(attempt(() => new Headers(pairs)))
-    if (!(init instanceof Obj) || isRuntimeReference(init)) {
-      throw typeError("new Headers(...) expects a record of names to values, iterable [name, value] pairs, or Headers.")
-    }
-    return wrap(
-      attempt(() => new Headers(Object.fromEntries(entries(init).map(([key, value]) => [key, coerceToString(value)])))),
-    )
-  })
-}
-
-export const headersGlobal = <R>(ctx: Interpreter<R>) => {
-  const builtins = ctx.builtins
-  const proto = builtins.Headers
-  const headers = constructor<R>(builtins, proto, {
-    name: "Headers",
-    call: requiresNew("Headers"),
-    construct: (args, newTarget) => constructHeaders(ctx, args[0], prototypeFrom(newTarget, proto)),
-  })
-  const self = (thisValue: unknown, name: string) => receiver(HeadersObj, thisValue, `Headers.prototype.${name}`)
-  const wrap = (items: Array<unknown>) => new Arr(builtins.Array, items)
-  const arg = (args: Array<unknown>, index: number): string => coerceToString(args[index])
-  const requireArgs = (name: string, args: Array<unknown>, count: number): void => {
-    if (args.length < count) throw typeError(`Headers.${name} requires ${count} argument${count === 1 ? "" : "s"}.`)
-  }
-  methods(builtins, proto, [
-    [
-      "append",
-      2,
-      (thisValue, args) => {
-        requireArgs("append", args, 2)
-        const target = self(thisValue, "append").headers
-        return attempt(() => target.append(arg(args, 0), arg(args, 1)))
-      },
-    ],
-    [
-      "delete",
-      1,
-      (thisValue, args) => {
-        requireArgs("delete", args, 1)
-        const target = self(thisValue, "delete").headers
-        return attempt(() => target.delete(arg(args, 0)))
-      },
-    ],
-    [
-      "get",
-      1,
-      (thisValue, args) => {
-        requireArgs("get", args, 1)
-        const target = self(thisValue, "get").headers
-        return attempt(() => target.get(arg(args, 0)))
-      },
-    ],
-    ["getSetCookie", 0, (thisValue) => wrap(self(thisValue, "getSetCookie").headers.getSetCookie())],
-    [
-      "has",
-      1,
-      (thisValue, args) => {
-        requireArgs("has", args, 1)
-        const target = self(thisValue, "has").headers
-        return attempt(() => target.has(arg(args, 0)))
-      },
-    ],
-    [
-      "set",
-      2,
-      (thisValue, args) => {
-        requireArgs("set", args, 2)
-        const target = self(thisValue, "set").headers
-        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.
-    [
-      "keys",
-      0,
-      (thisValue) => new IteratorObj(builtins.Iterator, Iterator.from(self(thisValue, "keys").headers.keys())),
-    ],
-    [
-      "values",
-      0,
-      (thisValue) => new IteratorObj(builtins.Iterator, Iterator.from(self(thisValue, "values").headers.values())),
-    ],
-    [
-      "entries",
-      0,
-      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
-          Iterator.from(self(thisValue, "entries").headers.entries()).map(([key, value]) => wrap([key, value])),
-        ),
-    ],
-    [
-      "forEach",
-      1,
-      (thisValue, args) => {
-        requireArgs("forEach", args, 1)
-        const target = self(thisValue, "forEach")
-        const apply = applyCollectionCallback(ctx, args[0], "Headers.forEach")
-        return Effect.gen(function* () {
-          for (const [key, value] of Array.from(target.headers.entries())) yield* apply([value, key, target])
-          return undefined
-        })
-      },
-    ],
-  ])
-  define(proto, IteratorSymbol, get(proto, "entries"), hidden)
-  return headers
-}
@@ -1,19 +0,0 @@
-import { methods, receiver } from "../interpreter/native.js"
-import { IteratorObj, record } from "../interpreter/objects.js"
-import type { Interpreter } from "../interpreter/interpreter.js"
-
-// Every built-in collection iterator shares the Iterator prototype; JS gives each collection its own, which is only
-// observable through getPrototypeOf.
-export const iteratorGlobals = <R>(ctx: Interpreter<R>): void => {
-  const builtins = ctx.builtins
-  methods(builtins, builtins.Iterator, [
-    [
-      "next",
-      0,
-      (thisValue) => {
-        const step = receiver(IteratorObj, thisValue, "Iterator.prototype.next").iterator.next()
-        return record(builtins.Object, { value: step.value, done: Boolean(step.done) })
-      },
-    ],
-  ])
-}
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
-import { constructor, fn, type Method, methods } from "../interpreter/native.js"
+import { constructor, type Method, methods } from "../interpreter/native.js"
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js"
-import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js"
-import { define, hidden, Arr, IteratorObj, PromiseObj, RegExpObj, record } from "../interpreter/objects.js"
+import { invalidData, rangeError, typeError } from "../interpreter/model.js"
+import { Arr, 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"
@@ -258,16 +258,5 @@ export const stringGlobal = <R>(ctx: Interpreter<R>) => {
      return joined
    }),
  ])
-  define(
-    builtins.String,
-    IteratorSymbol,
-    fn(
-      builtins,
-      "[Symbol.iterator]",
-      0,
-      (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "[Symbol.iterator]")[Symbol.iterator]()),
-    ),
-    hidden,
-  )
  return string
 }
@@ -1,19 +1,7 @@
 import { Effect } from "effect"
 import { constructor, fn, type Method, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js"
-import { IteratorSymbol, PendingThrow, typeError, uriError } from "../interpreter/model.js"
-import {
-  define,
-  defineAccessor,
-  entries,
-  get,
-  hidden,
-  isWrapper,
-  Arr,
-  IteratorObj,
-  Obj,
-  URLObj,
-  URLSearchParamsObj,
-} from "../interpreter/objects.js"
+import { PendingThrow, typeError, uriError } from "../interpreter/model.js"
+import { defineAccessor, entries, isWrapper, Arr, Obj, URLObj, URLSearchParamsObj } from "../interpreter/objects.js"
 import { isRuntimeReference } from "../interpreter/references.js"
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
@@ -119,10 +107,12 @@ export const urlGlobal = <R>(ctx: Interpreter<R>) => {
  return url
 }

-const readPair = <R>(ctx: Interpreter<R>, value: unknown, label: string): Effect.Effect<Array<string>, unknown, R> =>
+const readPair = <R>(ctx: Interpreter<R>, value: unknown): 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.`)
+    if (cursor === undefined) {
+      throw typeError("new URLSearchParams(...) expects iterable [name, value] pairs.")
+    }
    const items: Array<string> = []
    while (true) {
      const step = yield* cursor.next
@@ -136,29 +126,6 @@ const readPair = <R>(ctx: Interpreter<R>, value: unknown, label: string): Effect
    }
  })

-/**
- * Reads a synchronous iterable of `[name, value]` pairs as strings; `undefined` when `init` is not iterable. As in
- * WebIDL, the whole sequence is converted before any pair's length is checked.
- */
-export const readPairs = <R>(
-  ctx: Interpreter<R>,
-  init: unknown,
-  label: string,
-): Effect.Effect<Array<[string, string]> | undefined, unknown, R> =>
-  Effect.gen(function* () {
-    const cursor = yield* ctx.iterate(init)
-    if (cursor === undefined) return undefined
-    const pairs: Array<Array<string>> = []
-    while (true) {
-      const step = yield* cursor.next
-      if (step.done) {
-        if (pairs.some((entry) => entry.length !== 2)) throw typeError(`${label} expects iterable [name, value] pairs.`)
-        return pairs as Array<[string, string]>
-      }
-      pairs.push(yield* preserveConsumerError(cursor, readPair(ctx, step.value, label)))
-    }
-  })
-
 const constructURLSearchParams = <R>(
  ctx: Interpreter<R>,
  init: unknown,
@@ -172,8 +139,20 @@ const constructURLSearchParams = <R>(
    return Effect.succeed(wrap(new URLSearchParams(coerceToString(init))))
  }
  return Effect.gen(function* () {
-    const pairs = yield* readPairs(ctx, init, "new URLSearchParams(...)")
-    if (pairs !== undefined) return wrap(new URLSearchParams(pairs))
+    const cursor = yield* ctx.iterate(init)
+    if (cursor !== undefined) {
+      const pairs: Array<Array<string>> = []
+      while (true) {
+        const step = yield* cursor.next
+        if (step.done) {
+          if (pairs.some((entry) => entry.length !== 2)) {
+            throw typeError("new URLSearchParams(...) expects iterable [name, value] pairs.")
+          }
+          return wrap(new URLSearchParams(pairs.map((entry): [string, string] => [entry[0] ?? "", entry[1] ?? ""])))
+        }
+        pairs.push(yield* preserveConsumerError(cursor, readPair(ctx, step.value)))
+      }
+    }
    if (isRuntimeReference(init)) {
      throw typeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.")
    }
@@ -270,18 +249,13 @@ export const urlSearchParamsGlobal = <R>(ctx: Interpreter<R>) => {
        return undefined
      },
    ],
-    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").params.keys())],
-    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").params.values())],
+    ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").params.keys()))],
+    ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").params.values()))],
    [
      "entries",
      0,
      (thisValue) =>
-        new IteratorObj(
-          builtins.Iterator,
-          self(thisValue, "entries")
-            .params.entries()
-            .map(([key, value]) => wrap([key, value])),
-        ),
+        wrap(Array.from(self(thisValue, "entries").params.entries(), ([key, value]) => wrap([key, value]))),
    ],
    ["toString", 0, (thisValue) => self(thisValue, "toString").params.toString()],
    [
@@ -298,6 +272,5 @@ export const urlSearchParamsGlobal = <R>(ctx: Interpreter<R>) => {
      },
    ],
  ])
-  define(proto, IteratorSymbol, get(proto, "entries"), hidden)
  return searchParams
 }
@@ -13,7 +13,6 @@ import {
  SetObj,
  URLObj,
  URLSearchParamsObj,
-  HeadersObj,
 } from "../interpreter/objects.js"
 import type { Interpreter } from "../interpreter/interpreter.js"

@@ -29,7 +28,6 @@ export const coerceToString = (value: unknown): string => {
  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.
@@ -298,18 +298,21 @@ const cases = [
  },
  {
    path: "test/built-ins/Array/prototype/keys/iteration.js",
-    code: `const it = ["a", "b", "c"].keys(); return [it.next(), it.next(), it.next(), it.next()]`,
-    expected: [{ value: 0, done: false }, { value: 1, done: false }, { value: 2, done: false }, { done: true }],
+    code: `return ["a", "b", "c"].keys()`,
+    expected: [0, 1, 2],
  },
  {
    path: "test/built-ins/Array/prototype/values/iteration.js",
-    code: `const it = ["a", "b", "c"].values(); return [it.next(), it.next(), it.next(), it.next()]`,
-    expected: [{ value: "a", done: false }, { value: "b", done: false }, { value: "c", done: false }, { done: true }],
+    code: `return ["a", "b", "c"].values()`,
+    expected: ["a", "b", "c"],
  },
  {
    path: "test/built-ins/Array/prototype/entries/iteration.js",
-    code: `const it = ["a", "b"].entries(); return [it.next(), it.next(), it.next()]`,
-    expected: [{ value: [0, "a"], done: false }, { value: [1, "b"], done: false }, { done: true }],
+    code: `return ["a", "b"].entries()`,
+    expected: [
+      [0, "a"],
+      [1, "b"],
+    ],
  },
  {
    path: "test/built-ins/Array/isArray/15.4.3.2-0-3.js",
@@ -128,34 +128,6 @@ describe("values are converted at the boundary, never shared", () => {
    expect([...(held[0] as Set<{ z: number }>)][0]).toEqual({ z: 1 })
  })

-  test("Headers cross as copies in both directions", async () => {
-    const stored = new Headers({ "X-A": "1" })
-    const target = CodeMode.make({
-      extensions: [
-        Extension.make({
-          name: "http",
-          globals: {
-            headers: () => stored,
-            keep: (value: Headers) => {
-              held.push(value)
-              return value
-            },
-          },
-        }),
-      ],
-    })
-    held.length = 0
-    expect(
-      await value(
-        `const h = headers(); h.set("x-a", "2"); const back = keep(h); back.set("x-a", "3"); return [h instanceof Headers, h.get("x-a"), back === h, back.get("x-a"), [...back]]`,
-        target,
-      ),
-    ).toEqual([true, "2", false, "3", [["x-a", "3"]]])
-    expect(stored.get("x-a")).toBe("1")
-    expect(held[0]).toBeInstanceOf(Headers)
-    expect((held[0] as Headers).get("x-a")).toBe("2")
-  })
-
  test("bytes cross as copies in both directions; ArrayBuffer comes in as Uint8Array", async () => {
    const stored = new Uint8Array([1, 2, 3])
    const target = CodeMode.make({
@@ -220,9 +192,8 @@ describe("values are converted at the boundary, never shared", () => {
    expect(held[1]).toBeInstanceOf(Error)
  })

-  test("functions, promises, iterators, and symbols cannot be passed in", async () => {
+  test("functions, promises, and symbols cannot be passed in", async () => {
    expect((await failure(`keep(() => 1)`)).message).toContain("Argument 1 to keep contains a function")
-    expect((await failure(`keep([1].keys())`)).message).toContain("Argument 1 to keep contains an iterator")
    expect((await failure(`keep(later(1))`)).message).toContain("un-awaited Promise")
    expect((await failure(`keep(Symbol.iterator)`)).message).toContain("Argument 1 to keep contains a symbol")
  })
@@ -122,10 +122,10 @@ describe("Map.groupBy Test262 parity", () => {
          grouped.get(1),
          grouped.get("1"),
          grouped.has(stringable),
-          [...grouped.keys()].length,
+          grouped.keys().length,
          parity.get("even"),
          parity.get("odd"),
-          [...lengths.keys()],
+          lengths.keys(),
          lengths.get(5),
          lengths.get(4),
        ]
@@ -162,7 +162,7 @@ describe("Map.groupBy Test262 parity", () => {
      await value(`
        const grouped = Map.groupBy("🥰💩🙏😈", (char) => char < "🙏" ? "before" : "after")
        const empty = Map.groupBy([], () => { throw new Error("not called") })
-        return [[...grouped.keys()], grouped.get("before"), grouped.get("after"), empty.size]
+        return [grouped.keys(), grouped.get("before"), grouped.get("after"), empty.size]
      `),
    ).toEqual([["after", "before"], ["💩", "😈"], ["🥰", "🙏"], 0])
  })
@@ -502,9 +502,9 @@ describe("CodeMode-specific array behavior", () => {
    expect(err.message).toContain("circular")
  })

-  test("keys/values/entries return iterators usable with for...of and spread", async () => {
+  test("keys/values/entries return arrays 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"])
+    expect(await value(`return ["x","y"].values()`)).toEqual(["x", "y"])
    expect(
      await value(`
      const out = []
@@ -198,10 +198,10 @@ describe("Set composition Test262 parity", () => {
          keys: () => [-0],
        }
        return [
-          1 / [...new Set([1]).union(setlike)][1] === Infinity,
-          1 / [...new Set([0, 1, 2]).intersection(setlike)][0] === Infinity,
+          1 / new Set([1]).union(setlike).values()[1] === Infinity,
+          1 / new Set([0, 1, 2]).intersection(setlike).values()[0] === Infinity,
          [...new Set([0, 1]).difference(setlike)],
-          1 / [...new Set([1, 2]).symmetricDifference(setlike)][2] === Infinity,
+          1 / new Set([1, 2]).symmetricDifference(setlike).values()[2] === Infinity,
        ]
      `),
    ).toEqual([true, true, [1], true])
@@ -635,154 +635,6 @@ describe("URL and URI helpers", () => {
  })
 })

-describe("Headers", () => {
-  test("constructs from records, pairs, Maps, and Headers; names fold to lowercase and values combine", async () => {
-    expect(
-      await value(`
-        const headers = new Headers({ "Content-Type": "text/plain", "X-Count": 1, "X-Null": null })
-        headers.append("Accept", "text/html")
-        headers.append("accept", "application/json")
-        headers.set("x-count", "2")
-        headers.delete("x-null")
-        const copy = new Headers(headers)
-        copy.set("content-type", "text/html")
-        return {
-          get: headers.get("content-type"),
-          missing: headers.get("x-missing"),
-          combined: headers.get("ACCEPT"),
-          has: [headers.has("Accept"), headers.has("x-null")],
-          count: headers.get("x-count"),
-          copied: [headers.get("content-type"), copy.get("content-type")],
-          pairs: [...new Headers([["b", "2"], ["A", "1"]])],
-          map: [...new Headers(new Map([["k", "v"]]))],
-          keys: [...headers.keys()],
-          values: [...headers.values()],
-          entries: [...headers.entries()],
-        }
-      `),
-    ).toEqual({
-      get: "text/plain",
-      missing: null,
-      combined: "text/html, application/json",
-      has: [true, false],
-      count: "2",
-      copied: ["text/plain", "text/html"],
-      pairs: [
-        ["a", "1"],
-        ["b", "2"],
-      ],
-      map: [["k", "v"]],
-      keys: ["accept", "content-type", "x-count"],
-      values: ["text/html, application/json", "text/plain", "2"],
-      entries: [
-        ["accept", "text/html, application/json"],
-        ["content-type", "text/plain"],
-        ["x-count", "2"],
-      ],
-    })
-  })
-
-  test("iterates in sorted order everywhere iteration is allowed, and getSetCookie keeps cookies apart", async () => {
-    expect(
-      await value(`
-        const headers = new Headers({ b: "2", a: "1" })
-        headers.append("Set-Cookie", "x=1")
-        headers.append("set-cookie", "y=2")
-        const seen = []
-        headers.forEach((value, name, self) => seen.push(name + "=" + value + ":" + (self === headers)))
-        const [first] = headers
-        function* pairs() { yield* headers }
-        return {
-          seen,
-          first,
-          spread: [...headers],
-          from: Array.from(headers).length,
-          generator: [...pairs()].length,
-          object: Object.fromEntries(headers),
-          cookies: headers.getSetCookie(),
-        }
-      `),
-    ).toEqual({
-      seen: ["a=1:true", "b=2:true", "set-cookie=x=1:true", "set-cookie=y=2:true"],
-      first: ["a", "1"],
-      spread: [
-        ["a", "1"],
-        ["b", "2"],
-        ["set-cookie", "x=1"],
-        ["set-cookie", "y=2"],
-      ],
-      from: 4,
-      generator: 4,
-      object: { a: "1", b: "2", "set-cookie": "y=2" },
-      cookies: ["x=1", "y=2"],
-    })
-  })
-
-  test("serializes as a name-to-value object at the boundary and in JSON; prints for console", async () => {
-    const result = await run(`
-      const headers = new Headers({ "X-A": "1", b: "2" })
-      console.log(headers)
-      return { headers, json: JSON.stringify({ headers }), text: String(headers), type: typeof headers, is: headers instanceof Headers }
-    `)
-    expect(result.ok && result.value).toEqual({
-      headers: { b: "2", "x-a": "1" },
-      json: '{"headers":{"b":"2","x-a":"1"}}',
-      text: "[object Headers]",
-      type: "object",
-      is: true,
-    })
-    expect(result.ok && result.logs?.[0]).toBe('Headers {"b":"2","x-a":"1"}')
-  })
-
-  test("rejects what it cannot build from, and invalid names and values, with TypeErrors the program can catch", async () => {
-    expect(
-      await value(`
-        function message(run) {
-          try { run(); return null } catch (error) { return error instanceof TypeError ? error.message : error }
-        }
-        const headers = new Headers()
-        return [
-          message(() => Headers()),
-          message(() => new Headers(null)),
-          message(() => new Headers(1)),
-          message(() => new Headers("a=1")),
-          message(() => new Headers(new Date())),
-          message(() => new Headers(() => 1)),
-          message(() => new Headers([["name"]])),
-          message(() => new Headers([["a", "b", "c"]])),
-          message(() => new Headers({ "bad name": "x" })),
-          message(() => new Headers({ name: "bad\u0000value" })),
-          message(() => headers.get("invalid\u0100")),
-          message(() => headers.has({})),
-          message(() => headers.set("a", "invalid\u0100")),
-          message(() => headers.append("a")),
-          message(() => headers.forEach()),
-          message(() => headers.forEach(1)),
-          message(() => { const get = headers.get; return get("a") }),
-        ]
-      `),
-    ).toEqual([
-      "Constructor Headers requires 'new'.",
-      "new Headers(...) expects a record of names to values, iterable [name, value] pairs, or Headers.",
-      "new Headers(...) expects a record of names to values, iterable [name, value] pairs, or Headers.",
-      "new Headers(...) expects a record of names to values, iterable [name, value] pairs, or Headers.",
-      "new Headers(...) expects a record of names to values, iterable [name, value] pairs, or Headers.",
-      "new Headers(...) expects a record of names to values, iterable [name, value] pairs, or Headers.",
-      "new Headers(...) expects iterable [name, value] pairs.",
-      "new Headers(...) expects iterable [name, value] pairs.",
-      expect.stringContaining("bad name"),
-      expect.stringContaining("invalid value"),
-      expect.stringContaining("Invalid header name"),
-      expect.stringContaining("[object Object]"),
-      expect.stringContaining("invalid value"),
-      "Headers.append requires 2 arguments.",
-      "Headers.forEach requires 1 argument.",
-      "Headers.forEach expects a function callback.",
-      "Headers.prototype.get called on incompatible receiver undefined.",
-    ])
-  })
-})
-
 describe("Map", () => {
  test("get/set/has/size with chaining", async () => {
    expect(
@@ -816,28 +668,18 @@ describe("Map", () => {
    expect((await error(`return new Map(["flat"])`)).message).toMatch(/\[key, value\] pairs/)
  })

-  test("keys/values/entries return live iterators", async () => {
+  test("keys/values/entries return arrays", async () => {
    expect(
      await value(`
      const m = new Map([["a", 1], ["b", 2]])
-      const keys = m.keys()
-      const first = keys.next()
-      m.set("c", 3)
-      return { first, rest: [...keys], values: [...m.values()], entries: [...m.entries()], same: [...m[Symbol.iterator]()] }
+      return { keys: m.keys(), values: m.values(), entries: m.entries() }
    `),
    ).toEqual({
-      first: { value: "a", done: false },
-      rest: ["b", "c"],
-      values: [1, 2, 3],
+      keys: ["a", "b"],
+      values: [1, 2],
      entries: [
        ["a", 1],
        ["b", 2],
-        ["c", 3],
-      ],
-      same: [
-        ["a", 1],
-        ["b", 2],
-        ["c", 3],
      ],
    })
  })
@@ -1129,108 +971,6 @@ describe("TextEncoder and TextDecoder", () => {
  })
 })

-describe("built-in iterators", () => {
-  test("keys/values/entries and [Symbol.iterator] step with next() and stay live", async () => {
-    expect(
-      await value(`
-        const items = ["a"]
-        const it = items.entries()
-        items.push("b")
-        const steps = [it.next(), it.next(), it.next()]
-        items.push("c")
-        return { steps, after: it.next(), same: items[Symbol.iterator] === items.values }
-      `),
-    ).toEqual({
-      steps: [{ value: [0, "a"], done: false }, { value: [1, "b"], done: false }, { done: true }],
-      after: { done: true },
-      same: true,
-    })
-    expect(
-      await value(`
-        const s = new Set([1, 2])
-        const u = new URLSearchParams("a=1&b=2")
-        const h = new Headers({ b: "2", a: "1" })
-        const bytes = new Uint8Array([7, 8])
-        return [
-          [...s.entries()], [...s[Symbol.iterator]()], s[Symbol.iterator] === s.values,
-          [...u.keys()], [...u[Symbol.iterator]()], u[Symbol.iterator] === u.entries,
-          [...h.values()], [...h[Symbol.iterator]()], h[Symbol.iterator] === h.entries,
-          [...bytes.entries()], [...bytes[Symbol.iterator]()], bytes[Symbol.iterator] === bytes.values,
-          [..."ab"[Symbol.iterator]()],
-        ]
-      `),
-    ).toEqual([
-      [
-        [1, 1],
-        [2, 2],
-      ],
-      [1, 2],
-      true,
-      ["a", "b"],
-      [
-        ["a", "1"],
-        ["b", "2"],
-      ],
-      true,
-      ["1", "2"],
-      [
-        ["a", "1"],
-        ["b", "2"],
-      ],
-      true,
-      [
-        [0, 7],
-        [1, 8],
-      ],
-      [7, 8],
-      true,
-      ["a", "b"],
-    ])
-  })
-
-  test("iterators are consumed once by every iteration site", async () => {
-    expect(
-      await value(`
-        const it = [1, 2, 3, 4].values()
-        const picked = []
-        for (const item of it) { picked.push(item); if (item === 2) break }
-        const [third] = it
-        return { picked, third, rest: [...it], spent: Array.from(it), again: it[Symbol.iterator]() === it }
-      `),
-    ).toEqual({ picked: [1, 2], third: 3, rest: [4], spent: [], again: true })
-    expect(
-      await value(`
-        const m = new Map([["a", 1], ["b", 2]])
-        return [
-          Object.fromEntries(m.entries()), Array.from(m.keys(), (k) => k + "!"), new Set(m.values()).size,
-          await Promise.all([Promise.resolve(1), 2].values()),
-        ]
-      `),
-    ).toEqual([{ a: 1, b: 2 }, ["a!", "b!"], 2, [1, 2]])
-    expect(await value(`let s = 0; for await (const v of [Promise.resolve(1), 2].values()) s += v; return s`)).toBe(3)
-    expect(
-      await value(`return new Set([1, 2]).union({ size: 1, has: () => false, keys: () => new Set([3]).keys() })`),
-    ).toEqual([1, 2, 3])
-  })
-
-  test("iterators are opaque references", async () => {
-    expect(await value(`return [1].keys()`)).toEqual({})
-    expect(await value(`return JSON.stringify({ it: [1].keys() })`)).toBe('{"it":{}}')
-    expect(await value(`return [typeof [1].keys(), Array.isArray([1].keys()), Object.keys([1].keys())]`)).toEqual([
-      "object",
-      false,
-      [],
-    ])
-    const logged = await run(`console.log([1].keys()); return null`)
-    expect(logged.logs?.[0]).toBe("[opaque reference]")
-    expect((await error(`return [1].keys() + ""`)).message).toContain("Binary operators require data values")
-    expect((await error(`return [1].keys().next.call({})`)).message).toContain("is not a function")
-    expect((await error(`const it = [1].keys(); const next = it.next; return next()`)).message).toContain(
-      "Iterator.prototype.next called on incompatible receiver undefined",
-    )
-  })
-})
-
 describe("stdlib integration", () => {
  test("constructor follows own keys, shadowing, writes, and new", async () => {
    expect(
@@ -13,6 +13,8 @@ built-ins/Array/prototype/copyWithin/coerced-values-target.js  # Array.copyWithi
 built-ins/Array/prototype/copyWithin/return-abrupt-from-end.js  # Expected a Test262Error but got a TypeError
 built-ins/Array/prototype/copyWithin/return-abrupt-from-start.js  # Expected a Test262Error but got a TypeError
 built-ins/Array/prototype/copyWithin/return-abrupt-from-target.js  # Expected a Test262Error but got a TypeError
+built-ins/Array/prototype/entries/iteration-mutable.js  # .next is not a function.
+built-ins/Array/prototype/entries/iteration.js  # .next is not a function.
 built-ins/Array/prototype/every/15.4.4.16-7-6.js  # res Expected SameValue(«true», «false») to be true
 built-ins/Array/prototype/every/15.4.4.16-7-c-i-8.js  # [, , , ].every(callbackfn) Expected SameValue(«true», «false») to be true
 built-ins/Array/prototype/every/15.4.4.16-8-10.js  # … cannot be constructed: user-defined constructors and classes are not supported. Call it as a funct
@@ -84,6 +86,8 @@ built-ins/Array/prototype/join/S15.4.4.5_A3.1_T2.js  # Array.join expects zero a
 built-ins/Array/prototype/join/S15.4.4.5_A3.2_T2.js  # x.join() must return "*" Expected SameValue(«"[object Object]"», «"*"») to be true
 built-ins/Array/prototype/join/S15.4.4.5_A4_T3.js  # Array.prototype.join called on incompatible receiver a data object.
 built-ins/Array/prototype/join/S15.4.4.5_A5_T1.js  # #1: Array.prototype[1] = 1; x = [0]; x.length = 2; x.join() === "0,1". Actual: 0,
+built-ins/Array/prototype/keys/iteration-mutable.js  # .next is not a function.
+built-ins/Array/prototype/keys/iteration.js  # .next is not a function.
 built-ins/Array/prototype/lastIndexOf/15.4.4.15-5-1.js  # Array.lastIndexOf expects start index to be a number.
 built-ins/Array/prototype/lastIndexOf/15.4.4.15-5-15.js  # Array.lastIndexOf expects start index to be a number.
 built-ins/Array/prototype/lastIndexOf/15.4.4.15-5-16.js  # Array.lastIndexOf expects start index to be a number.
@@ -237,6 +241,9 @@ built-ins/Array/prototype/unshift/S15.4.4.13_A2_T3.js  # Array.prototype.unshift
 built-ins/Array/prototype/unshift/S15.4.4.13_A3_T2.js  # Array.prototype.unshift called on incompatible receiver a data object.
 built-ins/Array/prototype/unshift/S15.4.4.13_A4_T1.js  # Array.prototype.unshift called on incompatible receiver a data object.
 built-ins/Array/prototype/unshift/S15.4.4.13_A4_T2.js  # #3: Array.prototype[0] = 1; x = []; x.length = 1; x.unshift(0); x[1] === 1. Actual: undefined
+built-ins/Array/prototype/values/iteration-mutable.js  # .next is not a function.
+built-ins/Array/prototype/values/iteration.js  # .next is not a function.
+language/statements/async-function/rest-params-trailing-comma-early-error.js  # expected SyntaxError but the program ran
 language/statements/async-generator/dflt-params-abrupt.js  # Expected a Test262Error to be thrown but no exception was thrown at all
 language/statements/async-generator/dflt-params-ref-later.js  # Expected a ReferenceError to be thrown but no exception was thrown at all
 language/statements/async-generator/dflt-params-ref-self.js  # Expected a ReferenceError to be thrown but no exception was thrown at all
@@ -284,13 +291,16 @@ language/statements/async-generator/dstr/obj-ptrn-prop-id-init-throws.js  # Expe
 language/statements/async-generator/dstr/obj-ptrn-prop-id-init-unresolvable.js  # Expected a ReferenceError to be thrown but no exception was thrown at all
 language/statements/async-generator/dstr/obj-ptrn-prop-obj-value-null.js  # Expected a TypeError to be thrown but no exception was thrown at all
 language/statements/async-generator/dstr/obj-ptrn-prop-obj-value-undef.js  # Expected a TypeError to be thrown but no exception was thrown at all
+language/statements/async-generator/rest-params-trailing-comma-early-error.js  # expected SyntaxError but the program ran
 language/statements/async-generator/return-undefined-implicit-and-explicit.js  # Actual ["tick 1", "tick 2", "g1 ret", "g2 ret", "g3 ret", "g4 ret"] and expected ["tick 1", "g1 ret"
 language/statements/const/dstr/ary-init-iter-get-err-array-prototype.js  # Expected a TypeError to be thrown but no exception was thrown at all
+language/statements/for-await-of/async-func-decl-dstr-array-elem-init-in.js  # Failed to parse TypeScript: '…' expected.
 language/statements/for-await-of/async-func-decl-dstr-obj-empty-bool.js  # TypeError: Object destructuring requires a data object or array value, received a boolean.
 language/statements/for-await-of/async-func-decl-dstr-obj-empty-num.js  # TypeError: Object destructuring requires a data object or array value, received a number.
 language/statements/for-await-of/async-func-decl-dstr-obj-empty-string.js  # TypeError: Object destructuring requires a data object or array value, received a string.
 language/statements/for-await-of/async-func-decl-dstr-obj-rest-number.js  # TypeError: Object destructuring requires a data object or array value, received a number.
 language/statements/for-await-of/async-func-decl-dstr-obj-rest-str-val.js  # TypeError: Object destructuring requires a data object or array value, received a string.
+language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-in.js  # Failed to parse TypeScript: '…' expected.
 language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-rtrn-close-null.js  # "Promise incorrectly fulfilled."
 language/statements/for-await-of/async-gen-decl-dstr-obj-empty-bool.js  # TypeError: Object destructuring requires a data object or array value, received a boolean.
 language/statements/for-await-of/async-gen-decl-dstr-obj-empty-num.js  # TypeError: Object destructuring requires a data object or array value, received a number.
@@ -298,6 +308,8 @@ language/statements/for-await-of/async-gen-decl-dstr-obj-empty-string.js  # Type
 language/statements/for-await-of/async-gen-decl-dstr-obj-rest-number.js  # TypeError: Object destructuring requires a data object or array value, received a number.
 language/statements/for-await-of/async-gen-decl-dstr-obj-rest-str-val.js  # TypeError: Object destructuring requires a data object or array value, received a string.
 language/statements/for-in/head-lhs-member.js  # Unsupported for...in binding.
+language/statements/for-of/Array.prototype.Symbol.iterator.js  # The called value is not a function.
+language/statements/for-of/dstr/array-elem-init-in.js  # Failed to parse TypeScript: '…' expected.
 language/statements/for-of/dstr/array-elem-iter-rtrn-close-err.js  # Iterator next must be a function.
 language/statements/for-of/dstr/array-elem-iter-rtrn-close-null.js  # Expected a TypeError to be thrown but no exception was thrown at all
 language/statements/for-of/dstr/array-elem-iter-thrw-close-err.js  # Expected SameValue(«1», «0») to be true
@@ -343,6 +355,7 @@ language/statements/function/S14_A5_T1.js  # Identifier '…' has already been d
 language/statements/function/S14_A5_T2.js  # Identifier '…' has already been declared.
 language/statements/function/dstr/ary-init-iter-get-err-array-prototype.js  # Expected a TypeError to be thrown but no exception was thrown at all
 language/statements/function/dstr/dflt-ary-init-iter-get-err-array-prototype.js  # Expected a TypeError to be thrown but no exception was thrown at all
+language/statements/function/rest-params-trailing-comma-early-error.js  # expected SyntaxError but the program ran
 language/statements/generators/dflt-params-abrupt.js  # Expected a Test262Error to be thrown but no exception was thrown at all
 language/statements/generators/dflt-params-ref-later.js  # Expected a ReferenceError to be thrown but no exception was thrown at all
 language/statements/generators/dflt-params-ref-self.js  # Expected a ReferenceError to be thrown but no exception was thrown at all
@@ -393,6 +406,8 @@ language/statements/generators/dstr/obj-ptrn-prop-obj-value-undef.js  # Expected
 language/statements/generators/has-instance.js  # The right-hand side of '…' has no '…' object.
 language/statements/generators/prototype-typeof.js  # Expected SameValue(«"undefined"», «"object"») to be true
 language/statements/generators/prototype-uniqueness.js  # Expected true but got false
+language/statements/generators/rest-params-trailing-comma-early-error.js  # expected SyntaxError but the program ran
+language/statements/labeled/value-await-non-module-escaped.js  # Failed to parse TypeScript: Keywords cannot contain escape characters.
 language/statements/labeled/value-await-non-module.js  # Failed to parse TypeScript: Expression expected.
 language/statements/let/dstr/ary-init-iter-get-err-array-prototype.js  # Expected a TypeError to be thrown but no exception was thrown at all
 language/statements/return/S12.9_A1_T1.js  # expected SyntaxError but the program ran
@@ -3,13 +3,10 @@
 * - html/webappapis/atob/base64.any.js (btoa reference encoder, input list, and atob WebIDL cases)
 * - fetch/data-urls/resources/base64.json (copied to fixtures/wpt-base64.json)
 * - WebCryptoAPI/randomUUID.https.any.js
- * - fetch/api/headers/{headers-basic,headers-errors}.any.js
 *
 * Copyright © web-platform-tests contributors. Governed by the 3-Clause BSD license in LICENSE.wpt.
 *
 * `assert_throws_dom("InvalidCharacterError", …)` becomes a check for a TypeError: CodeMode has no DOMException.
- * `checkIteratorProperties` (prototype chain and property descriptors) and the custom iterator on a Headers
- * instance are left out.
 */
 import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
@@ -169,256 +166,3 @@ describe("crypto.randomUUID WPT parity (WebCryptoAPI/randomUUID.https.any.js)",
    ).toEqual([true, true, true, 768])
  })
 })
-
-// Enough of testharness.js to run the Headers files close to verbatim; each `test` records its failure, if any.
-const testharness = `
-  const failures = []
-  function test(run, name) { try { run() } catch (error) { failures.push(name + ": " + (error && error.message ? error.message : error)) } }
-  function assert_equals(actual, expected, message) { if (actual !== expected) throw new Error((message || "") + " expected " + JSON.stringify(expected) + " got " + JSON.stringify(actual)) }
-  function assert_true(actual, message) { assert_equals(actual, true, message) }
-  function assert_false(actual, message) { assert_equals(actual, false, message) }
-  function assert_array_equals(actual, expected, message) { assert_equals(JSON.stringify(actual), JSON.stringify(expected), message) }
-  function assert_throws_js(type, run) { try { run() } catch (error) { if (error instanceof type) return; throw new Error("threw " + error.name) } throw new Error("did not throw") }
-  function assert_unreached() { throw new Error("unreachable") }
-`
-
-describe("Headers WPT parity (fetch/api/headers)", () => {
-  test("headers-basic.any.js", async () => {
-    expect(
-      await value(`
-        ${testharness}
-        test(function() { new Headers() }, "Create headers from no parameter")
-        test(function() { new Headers(undefined) }, "Create headers from undefined parameter")
-        test(function() { new Headers({}) }, "Create headers from empty object")
-        var parameters = [null, 1]
-        parameters.forEach(function(parameter) {
-          test(function() { assert_throws_js(TypeError, function() { new Headers(parameter) }) }, "Create headers with " + parameter + " should throw")
-        })
-        var headerDict = {"name1": "value1", "name2": "value2", "name3": "value3", "name4": null, "name5": undefined, "name6": 1, "Content-Type": "value4"}
-        var headerSeq = []
-        for (var name in headerDict) headerSeq.push([name, headerDict[name]])
-        test(function() {
-          var headers = new Headers(headerSeq)
-          for (name in headerDict) assert_equals(headers.get(name), String(headerDict[name]), "name: " + name + " has value: " + headerDict[name])
-          assert_equals(headers.get("length"), null, "init should be treated as a sequence, not as a dictionary")
-        }, "Create headers with sequence")
-        test(function() {
-          var headers = new Headers(headerDict)
-          for (name in headerDict) assert_equals(headers.get(name), String(headerDict[name]), "name: " + name + " has value: " + headerDict[name])
-        }, "Create headers with record")
-        test(function() {
-          var headers = new Headers(headerDict)
-          var headers2 = new Headers(headers)
-          for (name in headerDict) assert_equals(headers2.get(name), String(headerDict[name]), "name: " + name + " has value: " + headerDict[name])
-        }, "Create headers with existing headers")
-        test(function() {
-          var headers = new Headers()
-          for (name in headerDict) {
-            headers.append(name, headerDict[name])
-            assert_equals(headers.get(name), String(headerDict[name]), "name: " + name + " has value: " + headerDict[name])
-          }
-        }, "Check append method")
-        test(function() {
-          var headers = new Headers()
-          for (name in headerDict) {
-            headers.set(name, headerDict[name])
-            assert_equals(headers.get(name), String(headerDict[name]), "name: " + name + " has value: " + headerDict[name])
-          }
-        }, "Check set method")
-        test(function() {
-          var headers = new Headers(headerDict)
-          for (name in headerDict) assert_true(headers.has(name), "headers has name " + name)
-          assert_false(headers.has("nameNotInHeaders"), "headers do not have header: nameNotInHeaders")
-        }, "Check has method")
-        test(function() {
-          var headers = new Headers(headerDict)
-          for (name in headerDict) {
-            assert_true(headers.has(name), "headers have a header: " + name)
-            headers.delete(name)
-            assert_true(!headers.has(name), "headers do not have anymore a header: " + name)
-          }
-        }, "Check delete method")
-        test(function() {
-          var headers = new Headers(headerDict)
-          for (name in headerDict) assert_equals(headers.get(name), String(headerDict[name]), "name: " + name + " has value: " + headerDict[name])
-          assert_equals(headers.get("nameNotInHeaders"), null, "header: nameNotInHeaders has no value")
-        }, "Check get method")
-        var headerEntriesDict = {"name1": "value1", "Name2": "value2", "name": "value3", "content-Type": "value4", "Content-Typ": "value5", "Content-Types": "value6"}
-        var sortedHeaderDict = {}
-        var headerValues = []
-        var sortedHeaderKeys = Object.keys(headerEntriesDict).map(function(value) {
-          sortedHeaderDict[value.toLowerCase()] = headerEntriesDict[value]
-          headerValues.push(headerEntriesDict[value])
-          return value.toLowerCase()
-        }).sort()
-        test(function() {
-          var headers = new Headers(headerEntriesDict)
-          var actual = headers.keys()
-          sortedHeaderKeys.forEach(function(key) {
-            const entry = actual.next()
-            assert_false(entry.done)
-            assert_equals(entry.value, key)
-          })
-          assert_true(actual.next().done)
-          assert_true(actual.next().done)
-          for (const key of headers.keys()) assert_true(sortedHeaderKeys.indexOf(key) != -1)
-        }, "Check keys method")
-        test(function() {
-          var headers = new Headers(headerEntriesDict)
-          var actual = headers.values()
-          sortedHeaderKeys.forEach(function(key) {
-            const entry = actual.next()
-            assert_false(entry.done)
-            assert_equals(entry.value, sortedHeaderDict[key])
-          })
-          assert_true(actual.next().done)
-          assert_true(actual.next().done)
-          for (const value of headers.values()) assert_true(headerValues.indexOf(value) != -1)
-        }, "Check values method")
-        test(function() {
-          var headers = new Headers(headerEntriesDict)
-          var actual = headers.entries()
-          sortedHeaderKeys.forEach(function(key) {
-            const entry = actual.next()
-            assert_false(entry.done)
-            assert_equals(entry.value[0], key)
-            assert_equals(entry.value[1], sortedHeaderDict[key])
-          })
-          assert_true(actual.next().done)
-          assert_true(actual.next().done)
-          for (const entry of headers.entries()) assert_equals(entry[1], sortedHeaderDict[entry[0]])
-        }, "Check entries method")
-        test(function() {
-          var headers = new Headers(headerEntriesDict)
-          var actual = headers[Symbol.iterator]()
-          sortedHeaderKeys.forEach(function(key) {
-            const entry = actual.next()
-            assert_false(entry.done)
-            assert_equals(entry.value[0], key)
-            assert_equals(entry.value[1], sortedHeaderDict[key])
-          })
-          assert_true(actual.next().done)
-          assert_true(actual.next().done)
-        }, "Check Symbol.iterator method")
-        test(function() {
-          var headers = new Headers(headerEntriesDict)
-          var reference = sortedHeaderKeys[Symbol.iterator]()
-          headers.forEach(function(value, key, container) {
-            assert_equals(headers, container)
-            const entry = reference.next()
-            assert_false(entry.done)
-            assert_equals(key, entry.value)
-            assert_equals(value, sortedHeaderDict[entry.value])
-          })
-          assert_true(reference.next().done)
-        }, "Check forEach method")
-        test(() => {
-          const headers = new Headers({"foo": "2", "baz": "1", "BAR": "0"})
-          const actualKeys = []
-          const actualValues = []
-          for (const [header, value] of headers) {
-            actualKeys.push(header)
-            actualValues.push(value)
-            headers.delete("foo")
-          }
-          assert_array_equals(actualKeys, ["bar", "baz"])
-          assert_array_equals(actualValues, ["0", "1"])
-        }, "Iteration skips elements removed while iterating")
-        test(() => {
-          const headers = new Headers({"foo": "2", "baz": "1", "BAR": "0", "quux": "3"})
-          const actualKeys = []
-          const actualValues = []
-          for (const [header, value] of headers) {
-            actualKeys.push(header)
-            actualValues.push(value)
-            if (header === "baz") headers.delete("bar")
-          }
-          assert_array_equals(actualKeys, ["bar", "baz", "quux"])
-          assert_array_equals(actualValues, ["0", "1", "3"])
-        }, "Removing elements already iterated over causes an element to be skipped during iteration")
-        test(() => {
-          const headers = new Headers({"foo": "2", "baz": "1", "BAR": "0", "quux": "3"})
-          const actualKeys = []
-          const actualValues = []
-          for (const [header, value] of headers) {
-            actualKeys.push(header)
-            actualValues.push(value)
-            if (header === "baz") headers.append("X-yZ", "4")
-          }
-          assert_array_equals(actualKeys, ["bar", "baz", "foo", "quux", "x-yz"])
-          assert_array_equals(actualValues, ["0", "1", "2", "3", "4"])
-        }, "Appending a value pair during iteration causes it to be reached during iteration")
-        test(() => {
-          const headers = new Headers({"foo": "2", "baz": "1", "BAR": "0", "quux": "3"})
-          const actualKeys = []
-          const actualValues = []
-          for (const [header, value] of headers) {
-            actualKeys.push(header)
-            actualValues.push(value)
-            if (header === "baz") headers.append("abc", "-1")
-          }
-          assert_array_equals(actualKeys, ["bar", "baz", "baz", "foo", "quux"])
-          assert_array_equals(actualValues, ["0", "1", "1", "2", "3"])
-        }, "Prepending a value pair before the current element position causes it to be skipped during iteration and adds the current element a second time")
-        return failures
-      `),
-    ).toEqual([])
-  })
-
-  test("headers-errors.any.js", async () => {
-    expect(
-      await value(`
-        ${testharness}
-        test(function() { assert_throws_js(TypeError, function() { new Headers([["name"]]) }) }, "Create headers giving an array having one string as init argument")
-        test(function() { assert_throws_js(TypeError, function() { new Headers([["invalid", "invalidValue1", "invalidValue2"]]) }) }, "Create headers giving an array having three strings as init argument")
-        test(function() { assert_throws_js(TypeError, function() { new Headers([["invalid\u0100", "Value1"]]) }) }, "Create headers giving bad header name as init argument")
-        test(function() { assert_throws_js(TypeError, function() { new Headers([["name", "invalidValue\u0100"]]) }) }, "Create headers giving bad header value as init argument")
-        var badNames = ["invalid\u0100", {}]
-        var badValues = ["invalid\u0100"]
-        badNames.forEach(function(name) {
-          test(function() { var headers = new Headers(); assert_throws_js(TypeError, function() { headers.get(name) }) }, "Check headers get with an invalid name " + name)
-        })
-        badNames.forEach(function(name) {
-          test(function() { var headers = new Headers(); assert_throws_js(TypeError, function() { headers.delete(name) }) }, "Check headers delete with an invalid name " + name)
-        })
-        badNames.forEach(function(name) {
-          test(function() { var headers = new Headers(); assert_throws_js(TypeError, function() { headers.has(name) }) }, "Check headers has with an invalid name " + name)
-        })
-        badNames.forEach(function(name) {
-          test(function() { var headers = new Headers(); assert_throws_js(TypeError, function() { headers.set(name, "Value1") }) }, "Check headers set with an invalid name " + name)
-        })
-        badValues.forEach(function(value) {
-          test(function() { var headers = new Headers(); assert_throws_js(TypeError, function() { headers.set("name", value) }) }, "Check headers set with an invalid value " + value)
-        })
-        badNames.forEach(function(name) {
-          test(function() { var headers = new Headers(); assert_throws_js(TypeError, function() { headers.append("invalid\u0100", "Value1") }) }, "Check headers append with an invalid name " + name)
-        })
-        badValues.forEach(function(value) {
-          test(function() { var headers = new Headers(); assert_throws_js(TypeError, function() { headers.append("name", value) }) }, "Check headers append with an invalid value " + value)
-        })
-        test(function() {
-          var headers = new Headers([["name", "value"]])
-          assert_throws_js(TypeError, function() { headers.forEach() })
-          assert_throws_js(TypeError, function() { headers.forEach(undefined) })
-          assert_throws_js(TypeError, function() { headers.forEach(1) })
-        }, "Headers forEach throws if argument is not callable")
-        test(function() {
-          var headers = new Headers([["name1", "value1"], ["name2", "value2"], ["name3", "value3"]])
-          var counter = 0
-          try {
-            headers.forEach(function(value, name) {
-              counter++
-              if (name == "name2") throw "error"
-            })
-          } catch (e) {
-            assert_equals(counter, 2)
-            assert_equals(e, "error")
-            return
-          }
-          assert_unreached()
-        }, "Headers forEach loop should stop if callback is throwing exception")
-        return failures
-      `),
-    ).toEqual([])
-  })
-})
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-app",
-  "version": "2.0.11",
+  "version": "2.0.8",
  "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.8",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-function",
-  "version": "2.0.11",
+  "version": "2.0.8",
  "$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.8",
  "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.8",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.11",
+  "version": "2.0.8",
  "name": "@opencode/core",
  "type": "module",
  "license": "MIT",
@@ -2,6 +2,7 @@ export * as McpInstructions from "./instructions.js"

 import { makeLocationNode } from "@opencode/util/effect/app-node"
 import { Context, Effect, Layer, Schema } from "effect"
+import { Agent } from "../agent.js"
 import { Permission } from "../permission.js"
 import { McpTool } from "../tool/mcp.js"
 import { Mcp } from "./index.js"
@@ -54,8 +55,7 @@ const update = (previous: ReadonlyArray<Summary>, current: ReadonlyArray<Summary
 }

 export interface Interface {
-  /** Lists server instructions reachable under the given ruleset; callers pass the merged agent and Session permissions. */
-  readonly load: (permissions: Permission.Ruleset) => Effect.Effect<Instructions.List>
+  readonly load: (agent: Agent.Selection) => Effect.Effect<Instructions.List>
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/McpInstructions") {}
@@ -66,7 +66,9 @@ export const layer = Layer.effect(
    const mcp = yield* Mcp.Service

    return Service.of({
-      load: Effect.fn("McpInstructions.load")(function* (permissions) {
+      load: Effect.fn("McpInstructions.load")(function* (selection) {
+        const agent = selection.info
+        if (!agent) return Instructions.empty
        const source = (value: ReadonlyArray<Summary> | Instructions.Removed) =>
          Instructions.make<ReadonlyArray<Summary>>({
            key: Instructions.Key.make("core/mcp-guidance"),
@@ -81,8 +83,8 @@ export const layer = Layer.effect(
        const [instructions, tools] = yield* Effect.all([mcp.instructions(), mcp.tools()], {
          concurrency: "unbounded",
        })
-        const canExecute = Permission.evaluate("execute", "*", permissions).effect !== "deny"
-        // Instructions are useful only when this Session can reach at least one server tool.
+        const canExecute = Permission.evaluate("execute", "*", agent.permissions).effect !== "deny"
+        // Instructions are useful only when this agent can reach at least one server tool.
        const visible = instructions
          .flatMap((item) => {
            const owned = tools.filter((tool) => tool.server === item.server)
@@ -91,7 +93,7 @@ export const layer = Layer.effect(
            if (
              !owned.some(
                (tool) =>
-                  Permission.evaluate(McpTool.name(tool.server, tool.name), "*", permissions).effect !== "deny",
+                  Permission.evaluate(McpTool.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny",
              )
            )
              return []
@@ -57,19 +57,16 @@ export const ModelsDevPlugin = define({
        })
      }
    })
-    const apply = (data: readonly ModelsDev.Snapshot[]) => {
-      loaded.data = snapshots(data)
-      return ctx.integration.reload().pipe(Effect.andThen(ctx.provider.reload()))
-    }
    yield* bus.subscribe(ModelsDev.Event.Refreshed).pipe(
-      Stream.runForEach(() => modelsDev.get().pipe(Effect.flatMap(apply))),
+      Stream.runForEach(() =>
+        modelsDev.get().pipe(
+          Effect.tap((data) => Effect.sync(() => (loaded.data = snapshots(data)))),
+          Effect.andThen(ctx.integration.reload()),
+          Effect.andThen(ctx.provider.reload()),
+        ),
+      ),
      Effect.forkScoped({ startImmediately: true }),
    )
-    // A refresh that landed between the initial read and the subscription above published
-    // Refreshed to nobody here. On a cold cache that read served the bundled snapshot, so
-    // re-read now instead of waiting for the next TTL refresh.
-    const latest = yield* modelsDev.get()
-    if (snapshots(latest) !== loaded.data) yield* apply(latest)
  }),
 })

@@ -127,16 +127,14 @@ const layer = Layer.effect(
      yield* mcpTools.flush
      const agent = yield* agents.select(session.agent)
      if (!agent.info) return yield* new AgentNotFoundError({ sessionID: session.id, agent: session.agent ?? agent.id })
-      // Session permissions narrow discovery the same way they narrow the tool snapshot.
-      const permissions = Permission.merge(agent.info.permissions, session.permissions ?? [])
      const loaded = yield* Effect.all(
        {
-          tools: registry.snapshot(permissions),
+          tools: registry.snapshot(Permission.merge(agent.info.permissions, session.permissions ?? [])),
          builtins: builtins.load(sessionID),
          discovery: discovery.load(),
-          skills: skillInstructions.load(permissions),
+          skills: skillInstructions.load(agent),
          references: referenceInstructions.load(),
-          mcp: mcpInstructions.load(permissions),
+          mcp: mcpInstructions.load(agent),
          entries: entries.load(sessionID),
        },
        { concurrency: "unbounded" },
@@ -20,10 +20,9 @@ import { SessionSchema } from "./schema.js"
 import { webSocketConstructor } from "../effect/app-node-platform.js"

 const ROTATE_AFTER_MS = 55 * 60 * 1000
-const CONNECT_TIMEOUT = "15 seconds"
+const INBOUND_CAPACITY = 128
+const CONNECT_TIMEOUT = "10 seconds"
 const IDLE_TIMEOUT = "5 minutes"
-/** Consecutive exchanges lost to the socket before the Session stays on HTTP. */
-const MAX_STREAM_FAILURES = 5
 const events = Metric.counter("opencode_session_websocket_events_total", {
  description: "Session WebSocket lifecycle events",
  incremental: true,
@@ -51,7 +50,6 @@ interface State {
  readonly lock: Semaphore.Semaphore
  closed: boolean
  httpFallback: boolean
-  streamFailures: number
  channel?: Channel
 }

@@ -128,7 +126,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
      const state = (sessionID: SessionSchema.ID) => {
        const current = states.get(sessionID)
        if (current) return current
-        const created = { lock: Semaphore.makeUnsafe(1), closed: false, httpFallback: false, streamFailures: 0 }
+        const created = { lock: Semaphore.makeUnsafe(1), closed: false, httpFallback: false }
        states.set(sessionID, created)
        return created
      }
@@ -170,27 +168,15 @@ export const makeLayer = (connector: WebSocketConnector) =>
          code: error.reason._tag === "Transport" ? error.reason.code : error.reason._tag,
          active: channel.active !== undefined,
        })
-        if (channel.active) {
-          Queue.failCauseUnsafe(channel.active.queue, Cause.fail(error))
-          yield* streamFailure(owner)
-        }
-        yield* metric("protocol_failure")
+        if (channel.active) Queue.failCauseUnsafe(channel.active.queue, Cause.fail(error))
+        yield* metric(
+          error.reason._tag === "Transport" && error.reason.code === "queue-overflow"
+            ? "queue_overflow"
+            : "protocol_failure",
+        )
        yield* channel.connection.close
      })

-      // A socket that keeps dying mid-exchange costs a retry every step; after enough consecutive
-      // losses the Session stays on HTTP.
-      const streamFailure = Effect.fn("SessionModelTransport.streamFailure")(function* (owner: State) {
-        owner.streamFailures++
-        if (owner.streamFailures < MAX_STREAM_FAILURES) return
-        owner.httpFallback = true
-        yield* Effect.logWarning("session websocket failed repeatedly; using http", {
-          sessionTransport: "websocket",
-          failures: owner.streamFailures,
-        })
-        yield* metric("fallback", { reason: "stream_failures" })
-      })
-
      const open = Effect.fn("SessionModelTransport.open")(function* (
        owner: State,
        exchange: WebSocketChannelExchange,
@@ -249,7 +235,14 @@ export const makeLayer = (connector: WebSocketConnector) =>
                      code: "message",
                      phase: "receive",
                    })
-                  Queue.offerUnsafe(active.queue, message)
+                  if (Queue.offerUnsafe(active.queue, message)) return undefined
+                  return yield* transportError("Session WebSocket inbound queue overflow", {
+                    url: exchange.connect.url,
+                    operation: "read",
+                    code: "queue-overflow",
+                    phase: "receive",
+                    delivery: "accepted",
+                  })
                }),
              ),
              Effect.catch((error) =>
@@ -262,7 +255,9 @@ export const makeLayer = (connector: WebSocketConnector) =>
                        phase:
                          error.reason._tag === "Transport" && error.reason.phase === "close" ? "close" : "receive",
                        delivery:
-                          channel.active?.delivery === "provider-observed" || channel.active?.delivery === "terminal"
+                          channel.active?.delivery === "provider-observed" ||
+                          channel.active?.delivery === "terminal" ||
+                          (error.reason._tag === "Transport" && error.reason.code === "queue-overflow")
                            ? "accepted"
                            : error.reason._tag === "Transport" && error.reason.code === "1009"
                              ? "rejected"
@@ -375,7 +370,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
          mode: create.mode,
        })
        const active: Active = {
-          queue: yield* Queue.unbounded<string, AIError>(),
+          queue: yield* Queue.bounded<string, AIError>(INBOUND_CAPACITY),
          delivery: "send-attempted",
        }
        channel.active = active
@@ -400,7 +395,6 @@ export const makeLayer = (connector: WebSocketConnector) =>
            return fallback(exchange)
          }
          yield* metric("ambiguous_delivery")
-          yield* streamFailure(owner)
          return yield* annotate(failure, { phase: "send", delivery: "ambiguous" })
        }
        yield* metric("send")
@@ -441,7 +435,6 @@ export const makeLayer = (connector: WebSocketConnector) =>
              const pending = yield* Queue.size(active.queue)
              yield* Queue.shutdown(active.queue)
              if (terminal && pending === 0) {
-                owner.streamFailures = 0
                yield* metric("terminal", { type: terminal.type })
                if (terminal.type === "rejected") yield* metric("rejection", { recovery: terminal.recovery })
                // The Codex backend stops serving a connection after any error frame: the next request is
@@ -4,6 +4,7 @@ import { makeLocationNode } from "@opencode/util/effect/app-node"
 import type { FSUtil } from "@opencode/util/fs-util"
 import path from "path"
 import { Context, Effect, Layer, Types } from "effect"
+import type { Agent } from "@opencode/schema/agent"
 import { Skill } from "@opencode/schema/skill"
 import { Bus } from "./bus.js"
 import { Permission } from "./permission.js"
@@ -30,8 +31,8 @@ export type Name = Skill.Name

 export { Event } from "@opencode/schema/skill"

-export const available = (skills: ReadonlyArray<Info>, permissions: Permission.Ruleset) =>
-  skills.filter((skill) => Permission.evaluate("skill", skill.id, permissions).effect !== "deny")
+export const available = (skills: ReadonlyArray<Info>, agent: Agent.Info) =>
+  skills.filter((skill) => Permission.evaluate("skill", skill.id, agent.permissions).effect !== "deny")

 export const toModelOutput = (skill: Info, files: ReadonlyArray<string>) => {
  const directory = path.dirname(skill.path)
@@ -2,7 +2,7 @@ export * as SkillInstructions from "./instructions.js"

 import { makeLocationNode } from "@opencode/util/effect/app-node"
 import { Context, Effect, Layer, Schema } from "effect"
-import { Permission } from "../permission.js"
+import { Agent } from "../agent.js"
 import { Skill } from "../skill.js"
 import { Instructions } from "../instructions/index.js"

@@ -58,8 +58,7 @@ const update = (previous: ReadonlyArray<Summary>, current: ReadonlyArray<Summary
 }

 export interface Interface {
-  /** Lists skills the given ruleset does not deny; callers pass the merged agent and Session permissions. */
-  readonly load: (permissions: Permission.Ruleset) => Effect.Effect<Instructions.List>
+  readonly load: (agent: Agent.Selection) => Effect.Effect<Instructions.List>
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/SkillInstructions") {}
@@ -70,8 +69,10 @@ const layer = Layer.effect(
    const skills = yield* Skill.Service

    return Service.of({
-      load: Effect.fn("SkillInstructions.load")(function* (permissions) {
-        const available = Skill.available(yield* skills.list(), permissions)
+      load: Effect.fn("SkillInstructions.load")(function* (selection) {
+        const agent = selection.info
+        if (!agent) return Instructions.empty
+        const available = Skill.available(yield* skills.list(), agent)
          .flatMap((skill) =>
            skill.description === undefined || skill.autoinvoke === false
              ? []
@@ -1,14 +1,23 @@
 import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
+import { Agent } from "@opencode/core/agent"
 import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder"
 import { Mcp } from "@opencode/core/mcp/index"
 import { McpInstructions } from "@opencode/core/mcp/instructions"
+import { Permission } from "@opencode/core/permission"
 import { McpTool } from "@opencode/core/tool/mcp"
 import { it } from "./lib/effect"
 import { readInitial, readUpdate } from "./lib/instructions"

+const build = Agent.ID.make("build")
+
+const selection = (permissions: Permission.Ruleset = []) => {
+  const info = Agent.Info.make({ ...Agent.Info.default(build), permissions })
+  return { id: info.id, info }
+}
+
 const instructions = (server: string, text: string) =>
-  ({ server: Mcp.ServerName.make(server), instructions: text }) satisfies Mcp.ServerInstructions
+  ({ server: Mcp.ServerName.make(server), instructions: text } satisfies Mcp.ServerInstructions)

 const schema = { type: "object" as const }
 const tool = (server: string, name = "search") =>
@@ -29,10 +38,12 @@ describe("McpInstructions", () => {
    Effect.gen(function* () {
      const service = yield* McpInstructions.Service
      const generation = yield* service
-        .load([
-          { action: McpTool.name("alpha", "restricted"), resource: "*", effect: "deny" },
-          { action: McpTool.name("hidden", "search"), resource: "*", effect: "deny" },
-        ])
+        .load(
+          selection([
+            { action: McpTool.name("alpha", "restricted"), resource: "*", effect: "deny" },
+            { action: McpTool.name("hidden", "search"), resource: "*", effect: "deny" },
+          ]),
+        )
        .pipe(Effect.flatMap(readInitial))

      expect(generation.text).toBe(
@@ -69,7 +80,7 @@ describe("McpInstructions", () => {
    Effect.gen(function* () {
      const service = yield* McpInstructions.Service
      const generation = yield* service
-        .load([{ action: "execute", resource: "*", effect: "deny" }])
+        .load(selection([{ action: "execute", resource: "*", effect: "deny" }]))
        .pipe(Effect.flatMap(readInitial))

      expect(generation.text).toBe("")
@@ -87,7 +98,7 @@ describe("McpInstructions", () => {
    Effect.gen(function* () {
      const service = yield* McpInstructions.Service
      const generation = yield* service
-        .load([{ action: "execute", resource: "*", effect: "deny" }])
+        .load(selection([{ action: "execute", resource: "*", effect: "deny" }]))
        .pipe(Effect.flatMap(readInitial))

      expect(generation.text).toBe(
@@ -103,14 +114,7 @@ describe("McpInstructions", () => {
      Effect.provide(
        layer(
          () => [instructions("alpha", "Alpha instructions")],
-          () => [
-            {
-              server: Mcp.ServerName.make("alpha"),
-              name: "search",
-              inputSchema: schema,
-              codemode: false,
-            } satisfies Mcp.Tool,
-          ],
+          () => [({ server: Mcp.ServerName.make("alpha"), name: "search", inputSchema: schema, codemode: false }) satisfies Mcp.Tool],
        ),
      ),
    ),
@@ -120,10 +124,10 @@ describe("McpInstructions", () => {
    let tools: Mcp.Tool[] = [tool("alpha")]
    return Effect.gen(function* () {
      const service = yield* McpInstructions.Service
-      const initialized = yield* service.load([]).pipe(Effect.flatMap(readInitial))
+      const initialized = yield* service.load(selection()).pipe(Effect.flatMap(readInitial))

      tools = [{ ...tool("alpha"), codemode: false }]
-      const changed = yield* readUpdate(yield* service.load([]), initialized)
+      const changed = yield* readUpdate(yield* service.load(selection()), initialized)
      expect(changed.text).toBe(
        [
          "The available MCP server instructions have changed. This list supersedes the previous one.",
@@ -149,10 +153,10 @@ describe("McpInstructions", () => {
    const tools = [tool("alpha"), tool("beta")]
    return Effect.gen(function* () {
      const service = yield* McpInstructions.Service
-      const initialized = yield* service.load([]).pipe(Effect.flatMap(readInitial))
+      const initialized = yield* service.load(selection()).pipe(Effect.flatMap(readInitial))

      catalog = [instructions("alpha", "Alpha instructions"), instructions("beta", "Beta instructions")]
-      const added = yield* readUpdate(yield* service.load([]), initialized)
+      const added = yield* readUpdate(yield* service.load(selection()), initialized)
      expect(added.text).toBe(
        [
          "New MCP server instructions are available in addition to those previously listed:",
@@ -164,7 +168,7 @@ describe("McpInstructions", () => {
      )

      catalog = [instructions("alpha", "Updated alpha"), instructions("beta", "Beta instructions")]
-      const changed = yield* readUpdate(yield* service.load([]), added)
+      const changed = yield* readUpdate(yield* service.load(selection()), added)
      expect(changed.text).toBe(
        [
          "The available MCP server instructions have changed. This list supersedes the previous one.",
@@ -182,11 +186,11 @@ describe("McpInstructions", () => {
      )

      catalog = [instructions("beta", "Beta instructions")]
-      const removed = yield* readUpdate(yield* service.load([]), changed)
+      const removed = yield* readUpdate(yield* service.load(selection()), changed)
      expect(removed.text).toBe("Instructions for the following MCP servers are no longer available: alpha.")

      catalog = []
-      expect((yield* readUpdate(yield* service.load([]), removed)).text).toBe(
+      expect((yield* readUpdate(yield* service.load(selection()), removed)).text).toBe(
        "MCP server instructions are no longer available.",
      )
    }).pipe(
@@ -290,37 +290,6 @@ describe("ModelsDevPlugin", () => {
    }),
  )

-  isolated.effect("adopts a refresh that completes between its initial read and its subscription", () =>
-    Effect.gen(function* () {
-      const bundled = richSnapshot("Acme Bundled")
-      const fresh = richSnapshot("Acme Fresh")
-      const current = { snapshot: bundled.snapshot }
-      const location = yield* owner
-      // Cold cache: the first read serves the bundled snapshot, and the boot-time
-      // ModelsDev.refresh() lands right after it, before the plugin subscribes.
-      const source = ModelsDev.Service.of({
-        get: () =>
-          Effect.gen(function* () {
-            const data = current.snapshot
-            if (data !== bundled.snapshot) return data
-            current.snapshot = fresh.snapshot
-            yield* location.bus.publish(ModelsDev.Event.Refreshed, {})
-            return data
-          }),
-        refresh: () => Effect.void,
-      })
-      yield* ModelsDevPlugin.effect(location.host).pipe(
-        Effect.provideService(ModelsDev.Service, source),
-        Effect.provideContext(location.context),
-      )
-      yield* TestClock.adjust("500 millis")
-      yield* TestClock.adjust("500 millis")
-      yield* TestClock.adjust("500 millis")
-
-      expect(required(yield* location.providers.get(bundled.providerID)).name).toBe("Acme Fresh")
-    }),
-  )
-
  real.effect("keeps the retained definition unchanged across model replay", () =>
    Effect.gen(function* () {
      const providers = yield* Provider.Service
@@ -593,7 +593,7 @@ describe("SessionModelTransport", () => {
          Effect.forkChild({ startImmediately: true }),
        )
        yield* Effect.yieldNow
-        yield* TestClock.adjust("15 seconds")
+        yield* TestClock.adjust("10 seconds")
        expect(yield* Fiber.join(running)).toEqual(["fallback:slow"])
      }),
    )
@@ -731,40 +731,6 @@ describe("SessionModelTransport", () => {
    )
  })

-  test("keeps the Session on HTTP after repeated mid-stream socket losses", async () => {
-    let opens = 0
-    const connector: WebSocketConnector = {
-      open: () =>
-        Effect.gen(function* () {
-          opens++
-          const messages = yield* Queue.unbounded<string | Uint8Array, AIError>()
-          return {
-            sendText: () =>
-              Effect.sync(() => {
-                Queue.failCauseUnsafe(messages, Cause.fail(error("socket dropped")))
-              }),
-            messages: Stream.fromQueue(messages),
-            close: Queue.shutdown(messages).pipe(Effect.asVoid),
-          }
-        }),
-    }
-
-    await run(
-      connector,
-      Effect.gen(function* () {
-        const transport = yield* SessionModelTransport.Service
-        const executor = transport.bind(session)
-        for (let attempt = 0; attempt < 5; attempt++) {
-          const result = yield* Effect.result(collect(executor, exchange(`attempt-${attempt}`)))
-          expect(result._tag).toBe("Failure")
-        }
-        expect(opens).toBe(5)
-        expect(yield* collect(executor, exchange("sixth"))).toEqual(["fallback:sixth"])
-        expect(opens).toBe(5)
-      }),
-    )
-  })
-
  test("falls back to HTTP after close code 1009 and keeps the Session on HTTP", async () => {
    const messages = queue<string | Uint8Array, AIError>()
    let opened = 0
@@ -949,22 +915,24 @@ describe("SessionModelTransport", () => {
    )
  })

-  test("buffers a synchronous burst of frames larger than any fixed capacity", async () => {
-    // Bun dispatches every frame in a read buffer in one tick; a large tool call streams thousands
-    // of small argument deltas, so the exchange must absorb the whole burst before it can consume.
-    const burst = 1500
+  test("poisons instead of dropping data when the inbound queue overflows", async () => {
    const messages = queue<string | Uint8Array, AIError>()
+    const poisoned = Deferred.makeUnsafe<void>()
    let closed = 0
    const connector: WebSocketConnector = {
      open: () =>
        Effect.succeed({
          sendText: () =>
+            // Hold consumption at the send boundary until the reader fills and poisons the inbound queue.
            Effect.sync(() => {
-              for (let index = 0; index < burst; index++) Queue.offerUnsafe(messages, `frame:${index}`)
-              Queue.offerUnsafe(messages, "completed")
-            }),
-          messages: Stream.fromQueue(messages),
-          close: Effect.sync(() => closed++).pipe(Effect.andThen(Queue.shutdown(messages)), Effect.asVoid),
+              for (let index = 0; index <= 129; index++) Queue.offerUnsafe(messages, `frame:${index}`)
+            }).pipe(Effect.andThen(Deferred.await(poisoned))),
+          messages: Stream.fromQueue(messages).pipe(Stream.tap(() => Effect.yieldNow)),
+          close: Effect.sync(() => closed++).pipe(
+            Effect.andThen(Deferred.succeed(poisoned, undefined)),
+            Effect.andThen(Queue.shutdown(messages)),
+            Effect.asVoid,
+          ),
        }),
    }

@@ -973,21 +941,20 @@ describe("SessionModelTransport", () => {
      Effect.gen(function* () {
        const transport = yield* SessionModelTransport.Service
        const item = exchange("first")
-        const frames = yield* collect(transport.bind(session), {
-          ...item,
-          driver: {
-            create: item.driver.create,
-            observe: (_create, frame) =>
-              Effect.succeed(
-                frame === "completed" ? { type: "completed" as const, frame } : { type: "frame" as const, frame },
-              ),
-          },
+        const result = yield* Effect.result(
+          collect(transport.bind(session), {
+            ...item,
+            driver: {
+              create: item.driver.create,
+              observe: (_create, frame) => Effect.succeed({ type: "frame" as const, frame }),
+            },
+          }),
+        )
+        expect(result).toMatchObject({
+          _tag: "Failure",
+          failure: { reason: { _tag: "Transport", code: "queue-overflow", delivery: "accepted" } },
        })
-        expect(frames).toHaveLength(burst + 1)
-        expect(frames.slice(0, 3)).toEqual(["frame:0", "frame:1", "frame:2"])
-        expect(frames.at(-2)).toBe(`frame:${burst - 1}`)
-        expect(frames.at(-1)).toBe("completed")
-        expect(closed).toBe(0)
+        expect(closed).toBe(1)
      }),
    )
  })
@@ -362,27 +362,21 @@ const layer = Layer.unwrap(
      load: () => Effect.succeed(Instructions.empty),
    })
    const skillInstructions = Layer.mock(SkillInstructions.Service, {
-      load: (permissions) => {
-        // `setup` tags each agent's ruleset with a `skill` rule naming that agent.
-        const baseline = permissions
-          .filter((rule) => rule.action === "skill")
-          .map((rule) => state.skillBaselines.get(Agent.ID.make(rule.resource)))
-          .findLast((text) => text !== undefined)
-        return Effect.succeed(
-          baseline === undefined
-            ? Instructions.empty
-            : Instructions.make({
+      load: (agent) =>
+        Effect.succeed(
+          state.skillBaselines.has(agent.id)
+            ? Instructions.make({
                key: Instructions.Key.make("test/skill-guidance"),
                codec: Schema.toCodecJson(Schema.String),
-                read: Effect.succeed(baseline),
+                read: Effect.succeed(state.skillBaselines.get(agent.id)!),
                render: {
                  initial: String,
                  changed: (_previous, current) => current,
                  removed: () => "Skill guidance removed",
                },
-              }),
-        )
-      },
+              })
+            : Instructions.empty,
+        ),
    })
    const referenceInstructions = Layer.mock(ReferenceInstructions.Service, {
      load: () => Effect.succeed(Instructions.empty),
@@ -532,17 +526,11 @@ const setup = Effect.gen(function* () {
  })
  yield* IdentityPlugin.Plugin.effect(pluginHost)
  yield* NativeCompactionPlugin.Plugin.effect(pluginHost)
-  yield* agents.transform((editor) => {
+  yield* agents.transform((editor) =>
    editor.update(Agent.ID.make("build"), (agent) => {
      agent.mode = "primary"
-    })
-    // Skill instructions receive only a ruleset, so tag each agent with a rule naming itself for the mock.
-    for (const id of ["build", "reviewer"]) {
-      editor.update(Agent.ID.make(id), (agent) => {
-        agent.permissions.push({ action: "skill", resource: id, effect: "allow" })
-      })
-    }
-  })
+    }),
+  )
  yield* db
    .insert(ProjectTable)
    .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
@@ -119,7 +119,7 @@ describe("Skill", () => {
        }),
      )
      const agent = yield* agents.get(Agent.ID.make("reviewer"))
-      expect(Skill.available([info("deploy", "Deploy")], agent!.permissions)).toEqual([])
+      expect(Skill.available([info("deploy", "Deploy")], agent!)).toEqual([])
    }),
  )
 })
@@ -53,7 +53,7 @@ describe("SkillInstructions", () => {
    let skills = [hidden, denied, manual, effect]
    return Effect.gen(function* () {
      const instructions = yield* SkillInstructions.Service
-      const initialized = yield* instructions.load(agent.permissions).pipe(Effect.flatMap(readInitial))
+      const initialized = yield* instructions.load({ id: agent.id, info: agent }).pipe(Effect.flatMap(readInitial))

      expect(initialized.text).toBe(
        [
@@ -74,7 +74,7 @@ describe("SkillInstructions", () => {
      skills = []
      expect(
        yield* instructions
-          .load(agent.permissions)
+          .load({ id: agent.id, info: agent })
          .pipe(Effect.flatMap((context) => readUpdate(context, initialized))),
      ).toMatchObject({ text: "Skill guidance is no longer available. Do not use any previously listed skill." })
    }).pipe(Effect.provide(layer(() => skills)))
@@ -92,11 +92,11 @@ describe("SkillInstructions", () => {
    let skills = [effect]
    return Effect.gen(function* () {
      const instructions = yield* SkillInstructions.Service
-      const initialized = yield* instructions.load(agent.permissions).pipe(Effect.flatMap(readInitial))
+      const initialized = yield* instructions.load({ id: agent.id, info: agent }).pipe(Effect.flatMap(readInitial))

      skills = [effect, debugging]
      const added = yield* instructions
-        .load(agent.permissions)
+        .load({ id: agent.id, info: agent })
        .pipe(Effect.flatMap((context) => readUpdate(context, initialized)))
      expect(added.text).toBe(
        [
@@ -111,7 +111,7 @@ describe("SkillInstructions", () => {

      skills = [debugging]
      const removed = yield* instructions
-        .load(agent.permissions)
+        .load({ id: agent.id, info: agent })
        .pipe(Effect.flatMap((context) => readUpdate(context, added)))
      expect(removed.text).toBe("The following skill IDs are no longer available and must not be used: effect.")
    }).pipe(Effect.provide(layer(() => skills)))
@@ -122,12 +122,12 @@ describe("SkillInstructions", () => {
    let skills = [effect]
    return Effect.gen(function* () {
      const instructions = yield* SkillInstructions.Service
-      const initialized = yield* instructions.load(agent.permissions).pipe(Effect.flatMap(readInitial))
+      const initialized = yield* instructions.load({ id: agent.id, info: agent }).pipe(Effect.flatMap(readInitial))

      skills = [Skill.Info.make({ ...effect, description: "Build applications with Effect v4" })]
      expect(
        yield* instructions
-          .load(agent.permissions)
+          .load({ id: agent.id, info: agent })
          .pipe(Effect.flatMap((context) => readUpdate(context, initialized))),
      ).toMatchObject({
        text: expect.stringContaining(
@@ -144,7 +144,7 @@ describe("SkillInstructions", () => {
    })
    return Effect.gen(function* () {
      const instructions = yield* SkillInstructions.Service
-      expect((yield* instructions.load(agent.permissions).pipe(Effect.flatMap(readInitial))).text).toBe("")
+      expect((yield* instructions.load({ id: agent.id, info: agent }).pipe(Effect.flatMap(readInitial))).text).toBe("")
    }).pipe(Effect.provide(layer(() => [effect])))
  })

@@ -158,7 +158,7 @@ describe("SkillInstructions", () => {
    })
    return Effect.gen(function* () {
      const instructions = yield* SkillInstructions.Service
-      expect((yield* instructions.load(agent.permissions).pipe(Effect.flatMap(readInitial))).text).toBe("")
+      expect((yield* instructions.load({ id: agent.id, info: agent }).pipe(Effect.flatMap(readInitial))).text).toBe("")
    }).pipe(Effect.provide(layer(() => [effect])))
  })

@@ -173,7 +173,7 @@ describe("SkillInstructions", () => {
    return Effect.gen(function* () {
      const instructions = yield* SkillInstructions.Service
      expect(
-        (yield* instructions.load(agent.permissions).pipe(Effect.flatMap(readInitial))).text,
+        (yield* instructions.load({ id: agent.id, info: agent }).pipe(Effect.flatMap(readInitial))).text,
      ).toContain("<name>Effect</name>")
    }).pipe(Effect.provide(layer(() => [effect])))
  })
@@ -189,7 +189,7 @@ describe("SkillInstructions", () => {
    })
    return Effect.gen(function* () {
      const instructions = yield* SkillInstructions.Service
-      expect((yield* instructions.load(agent.permissions).pipe(Effect.flatMap(readInitial))).text).toBe("")
+      expect((yield* instructions.load({ id: agent.id, info: agent }).pipe(Effect.flatMap(readInitial))).text).toBe("")
    }).pipe(Effect.provide(layer(() => [effect])))
  })
 })
@@ -28,29 +28,6 @@ const sentry =
      })
    : false

-// Every module the entry reaches through static imports lands in one chunk. Automatic splitting
-// otherwise fragments the initial graph into ~50 files shared with lazy routes, and each file costs
-// the renderer a main-thread request round trip through the main process before first paint.
-type ChunkingContext = { getModuleInfo(id: string): { isEntry: boolean; importers: readonly string[] } | null }
-const initialGraph = new WeakMap<ChunkingContext, Map<string, boolean>>()
-function inInitialGraph(id: string, ctx: ChunkingContext) {
-  const memo = initialGraph.get(ctx) ?? new Map<string, boolean>()
-  initialGraph.set(ctx, memo)
-  const visit = (id: string, path: Set<string>): boolean => {
-    const known = memo.get(id)
-    if (known !== undefined) return known
-    if (path.has(id)) return false
-    const info = ctx.getModuleInfo(id)
-    if (!info) return false
-    path.add(id)
-    const result = info.isEntry || info.importers.some((importer) => visit(importer, path))
-    path.delete(id)
-    memo.set(id, result)
-    return result
-  }
-  return visit(id, new Set())
-}
-
 export default defineConfig(({ command }) => ({
  main: {
    resolve: {
@@ -133,11 +110,6 @@ const require = __cjs_mod__.createRequire(import.meta.url);
        input: {
          main: "src/renderer/index.html",
        },
-        output: {
-          codeSplitting: {
-            groups: [{ name: (id, ctx) => (inInitialGraph(id, ctx) ? "app" : null), priority: 10 }],
-          },
-        },
      },
    },
  },
@@ -1,7 +1,7 @@
 {
  "name": "@opencode/desktop",
  "private": true,
-  "version": "2.0.11",
+  "version": "2.0.8",
  "type": "module",
  "license": "MIT",
  "homepage": "https://opencode.ai",
@@ -191,14 +191,8 @@ const phaseOrder = [
  ["electron js init → entry", "nodeBootstrapped", "entryStart"],
  ["entry → chromium ready", "entryStart", "electronReady"],
  ["ready → window shown", "electronReady", "windowVisible"],
-  ["window → renderer assets served", "windowVisible", "rendererAssetsServed"],
-  ["main bundle load + evaluate", "rendererAssetsServed", "bundleEvaluated"],
-  ["bundle → onboarding decided", "bundleEvaluated", "onboardingDecided"],
-  ["onboarding → logging ready", "onboardingDecided", "loggingReady"],
-  ["logging → first log line", "loggingReady", "appStarting"],
-  ["first log line → storage open", "appStarting", "storageOpen"],
-  ["storage → initialization done", "storageOpen", "initializationDone"],
-  ["initialization → layers ready", "initializationDone", "layersReady"],
+  ["main bundle load + evaluate", "windowVisible", "bundleEvaluated"],
+  ["layers → first log line", "bundleEvaluated", "appStarting"],
  ["layers → renderer process", "appStarting", "rendererProcess"],
  ["renderer boot → first paint", "rendererProcess", "firstPaint"],
  ["first paint → shell", "firstPaint", "shellVisible"],
@@ -403,15 +397,8 @@ async function launch(build: { label: string; exe: string }, run: number): Promi
      nodeBootstrapped: boot && Math.round(boot.origin + boot.bootstrapComplete - spawnAt),
      entryStart: main.marks.entry && main.marks.entry - spawnAt,
      electronReady: main.marks.ready && main.marks.ready - spawnAt,
-      rendererAssetsServed: main.marks.served && main.marks.served - spawnAt,
      bundleEvaluated: main.marks.bundle && main.marks.bundle - spawnAt,
-      onboardingDecided: main.marks.onboarding && main.marks.onboarding - spawnAt,
-      loggingReady: main.marks.logging && main.marks.logging - spawnAt,
-      crashReporterStarted: main.marks.crash && main.marks.crash - spawnAt,
      appStarting: main.appStarting && main.appStarting - spawnAt,
-      storageOpen: main.marks.storage && main.marks.storage - spawnAt,
-      initializationDone: main.marks.init && main.marks.init - spawnAt,
-      layersReady: main.marks.layers && main.marks.layers - spawnAt,
      cliVersionStart: main.versionStart && main.versionStart - spawnAt,
      cliVersionDone: main.versionDone && main.versionDone - spawnAt,
      serviceStarting: main.serviceStarting && main.serviceStarting - spawnAt,
@@ -606,8 +593,8 @@ function mainLog() {
      // A window shown before the logger existed reports when it was shown; the line itself is later.
      const shown = /main window visible/.test(message) ? entry.match(/shownAt: (\d+)/)?.[1] : undefined
      if (shown) windowShownAt = Number(shown)
-      if (/app starting|layers ready/.test(message))
-        for (const [, key, value] of entry.matchAll(/\b(\w+): (\d{10,})/g)) marks[key] = Number(value)
+      if (/app starting/.test(message))
+        for (const [, key, value] of entry.matchAll(/\b(entry|ready|window|bundle): (\d{10,})/g)) marks[key] = Number(value)
      timeline.push([new Date(m[1].replace(" ", "T")).getTime(), name.replace(/\.log$/, ""), message])
    }
  }
@@ -1,10 +0,0 @@
-param([Parameter(Mandatory)][string]$Name, [int]$Runs = 5)
-$ErrorActionPreference = "Stop"
-Set-Location $PSScriptRoot\..
-# electron-vite directly: the package's prebuild hook re-downloads the CLI, which the bench keeps fixed.
-bunx electron-vite build 2>&1 | Select-String -Pattern "built in|error" | Select-Object -Last 3
-if (-not (Test-Path out\main\index.js)) { throw "build failed" }
-bunx electron-builder --win --dir --config electron-builder.config.ts 2>&1 | Select-String -Pattern "error|signing with signtool.*OpenCode Dev" | Select-Object -Last 2
-if (Test-Path "dist\$Name-unpacked") { Remove-Item "dist\$Name-unpacked" -Recurse -Force }
-Rename-Item -Path dist\win-unpacked -NewName "$Name-unpacked"
-bun ./scripts/bench-startup.ts --exe "dist\base-unpacked\OpenCode Dev.exe" --compare "dist\$Name-unpacked\OpenCode Dev.exe" --runs $Runs --warmup 1 --window-at=-1700,20 --out "dist\bench-startup\$Name" 2>&1 | Select-String -Pattern "^warm service|^\s{2,}|^phases|^\S+\s+\d+\s+\(|^report|^warm-up|Error|error" | Select-Object -Last 45
@@ -1,94 +0,0 @@
-// Attribute a renderer .cpuprofile's self time to original source files through the build's
-// source maps. Run with: bun scripts/profile-by-source.ts <profile.cpuprofile> [out/renderer/assets]
-import { readFileSync, readdirSync } from "node:fs"
-import { join } from "node:path"
-import { TraceMap, originalPositionFor } from "C:/Users/Lukem/.local/share/opencode/worktree/6c1049/quiet-wolf-2/node_modules/.bun/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs"
-
-const profilePath = process.argv[2]!
-const assets = process.argv[3] ?? "out/renderer/assets"
-const profile = JSON.parse(readFileSync(profilePath, "utf8"))
-const maps = new Map<string, TraceMap>()
-for (const name of readdirSync(assets).filter((f) => f.endsWith(".js.map"))) {
-  maps.set(name.slice(0, -4), new TraceMap(JSON.parse(readFileSync(join(assets, name), "utf8"))))
-}
-
-const nodes = new Map<number, any>()
-for (const n of profile.nodes) nodes.set(n.id, n)
-const self = new Map<string, number>()
-const byPkg = new Map<string, number>()
-const group = (source: string) => {
-  const n = source.replace(/\\/g, "/")
-  const nm = n.match(/node_modules\/(?:\.bun\/[^/]+\/node_modules\/)?((?:@[^/]+\/)?[^/]+)(?:\/dist\/([^/]+))?/)
-  if (nm) return nm[1] === "effect" ? `effect/${(nm[2] ?? "").replace(/\.js$/, "")}` : nm[1]
-  const pk = n.match(/packages\/([^/]+)\/src\/(.+)$/)
-  return pk ? `${pk[1]}/${pk[2]}` : n.slice(-50)
-}
-const parent = new Map<number, number>()
-for (const n of profile.nodes) for (const c of n.children ?? []) parent.set(c, n.id)
-const resolve = (frame: any) => {
-  const name = frame.functionName
-  if (name === "(program)" || name === "(garbage collector)") return { label: name, fn: name }
-  const file = frame.url.split("/").pop()
-  const map = maps.get(file)
-  if (!map) return { label: `(no map) ${file}`, fn: name }
-  const pos = originalPositionFor(map, { line: frame.lineNumber + 1, column: frame.columnNumber })
-  return { label: pos.source ? group(pos.source) : `(unmapped) ${file}`, fn: pos.name ?? name }
-}
-const labelOf = (frame: any) => resolve(frame).label
-// A sample belongs to the render phase once Solid's root is on the stack; everything before that is
-// module evaluation, everything after the first render is later work (hydration, effects, timers).
-const stackHas = (id: number, test: (label: string, fn: string) => boolean) => {
-  for (let cur: number | undefined = id; cur !== undefined; cur = parent.get(cur)) {
-    const resolved = resolve(nodes.get(cur).callFrame)
-    if (test(resolved.label, resolved.fn)) return true
-  }
-  return false
-}
-const phases = { evaluate: new Map<string, number>(), render: new Map<string, number>(), later: new Map<string, number>() }
-let phase: keyof typeof phases = "evaluate"
-let t = 0
-let total = 0
-for (let i = 0; i < profile.samples.length; i++) {
-  const dt = (profile.timeDeltas[i] ?? 0) / 1000
-  t += dt
-  const node = nodes.get(profile.samples[i])
-  if (node.callFrame.functionName === "(idle)") {
-    if (phase === "render" && dt > 5) phase = "later"
-    continue
-  }
-  total += dt
-  if (phase === "evaluate" && stackHas(node.id, (label, fn) => label === "solid-js" && (fn === "render" || fn === "createRoot")))
-    phase = "render"
-  const label = labelOf(node.callFrame)
-  const bucket = phases[phase]
-  bucket.set(label, (bucket.get(label) ?? 0) + dt)
-  self.set(label, (self.get(label) ?? 0) + dt)
-  const pkg = label.split("/").slice(0, label.startsWith("effect/") || label.startsWith("@") ? 2 : 1).join("/")
-  byPkg.set(pkg, (byPkg.get(pkg) ?? 0) + dt)
-}
-console.log(`busy ${total.toFixed(0)} ms over ${t.toFixed(0)} ms`)
-void phases
-// Timeline: 25 ms buckets with the top sources, so module evaluation, render and hydration show as bands.
-const buckets = new Map<number, Map<string, number>>()
-t = 0
-for (let i = 0; i < profile.samples.length; i++) {
-  const dt = (profile.timeDeltas[i] ?? 0) / 1000
-  t += dt
-  const node = nodes.get(profile.samples[i])
-  if (node.callFrame.functionName === "(idle)") continue
-  const b = Math.floor(t / 25) * 25
-  const m = buckets.get(b) ?? new Map()
-  const label = labelOf(node.callFrame).replace(/^(\.\.\/)+/, "")
-  m.set(label, (m.get(label) ?? 0) + dt)
-  buckets.set(b, m)
-}
-console.log("\n== timeline (25 ms buckets) ==")
-for (const [b, m] of [...buckets].sort((a, c) => a[0] - c[0])) {
-  const busy = [...m.values()].reduce((a, c) => a + c, 0)
-  if (busy < 1) continue
-  const top = [...m].sort((a, c) => c[1] - a[1]).slice(0, 4).map(([k, v]) => `${k} ${v.toFixed(0)}`).join(" | ")
-  console.log(String(b).padStart(5), busy.toFixed(0).padStart(3), top)
-}
-console.log("\n== by package (all) ==")
-for (const [k, v] of [...byPkg].sort((a, b) => b[1] - a[1]).slice(0, 20)) console.log(v.toFixed(1).padStart(7), k)
-
@@ -103,17 +103,11 @@ export function createBrowserPage(
    revision++
  })
  let closed = false
-  // Whether the native surface holds a real document worth showing. Chromium keeps the
-  // previous document painted until the next one renders, so a shown page stays shown
-  // through later navigations; blank and failed documents hide until a real one is ready.
-  let content = false
-  let failure: { url: string; message: string } | undefined
  const state = (): Browser.Tab => ({
    id: options.id,
-    url: (failure?.url ?? contents.getURL()).slice(0, 16_384),
+    url: contents.getURL().slice(0, 16_384),
    title: contents.getTitle().slice(0, 2_048),
    loading: contents.isLoading(),
-    ...(failure ? { loadError: failure.message } : {}),
    canGoBack: contents.navigationHistory.canGoBack(),
    canGoForward: contents.navigationHistory.canGoForward(),
    generation,
@@ -121,40 +115,16 @@ export function createBrowserPage(
  const publish = () => {
    if (!closed) options.publish()
  }
-  const reset = (event: Electron.Event<{ url: string; isMainFrame: boolean; isSameDocument: boolean }>) => {
+  const reset = (event: Electron.Event<{ isMainFrame: boolean; isSameDocument: boolean }>) => {
    if (!event.isMainFrame || event.isSameDocument) return
-    failure = undefined
    generation++
    documents.clear()
    refs.clear()
    diagnostics.clear()
    publish()
  }
-  const settle = () => {
-    content = contents.getURL() !== "about:blank" && !failure
-    updateVisibility()
-  }
  contents.on("did-start-navigation", reset)
-  contents.on("did-navigate", (_event, url, status, statusText) => {
-    // The server-network proxy answers an unreachable HTTP target with an empty 502. Other
-    // error statuses are real documents from the user's server and stay visible.
-    if (status === 502) failure = { url, message: `${status} ${statusText}`.trim().slice(0, 2_048) }
-    // A blank or failed document paints at commit; a real one waits for dom-ready.
-    if (url === "about:blank" || failure) settle()
-    publish()
-  })
-  contents.on("did-fail-load", (_event, code, description, url, isMainFrame) => {
-    // Cancelled navigation and failed subframes do not replace the current page.
-    if (!isMainFrame || code === -3) return
-    failure = { url, message: description.slice(0, 2_048) }
-    settle()
-    publish()
-  })
-  contents.on("dom-ready", settle)
-  contents.on("did-stop-loading", () => {
-    settle()
-    publish()
-  })
+  contents.on("did-stop-loading", publish)
  contents.on("did-navigate-in-page", publish)
  contents.on("page-title-updated", publish)
  contents.on("render-process-gone", () => {
@@ -282,14 +252,6 @@ export function createBrowserPage(
    corner.setVisible(false)
    win.contentView.addChildView(corner)
  })
-  let visible = false
-  const updateVisibility = () => {
-    // The renderer's layout requests may lag behind navigation; the page decides
-    // whether there is a document worth exposing over the themed background.
-    const show = visible && content
-    view.setVisible(show)
-    corners.forEach((corner) => corner.setVisible(show && !!cornerKey))
-  }
  const ready = Promise.all([
    files.ready,
    ...(options.initialize === false
@@ -340,9 +302,9 @@ export function createBrowserPage(
        )
      })
    },
-    setVisible(value: boolean) {
-      visible = value
-      updateVisibility()
+    setVisible(visible: boolean) {
+      view.setVisible(visible)
+      corners.forEach((corner) => corner.setVisible(visible && !!cornerKey))
    },
    async execute(command: Browser.Command, signal: AbortSignal): Promise<Browser.Result> {
      await ready
@@ -5,7 +5,6 @@ import { Ipc } from "./ipc"
 import { DesktopInitialization } from "./lifecycle/desktop-initialization"
 import { installContextMenu } from "./lifecycle/environment"
 import { ApplicationLifecycle } from "./lifecycle"
-import { DesktopLogging } from "./native/logging"
 import { BackgroundService } from "./service/background-service"
 import { DesktopCli } from "./service/desktop-cli"
 import { UpdaterLive } from "./updater/live"
@@ -16,15 +15,8 @@ marks.bundle = Date.now()

 const runIpc = Effect.fn("Desktop.runIpc")(function* () {
  const lifecycle = yield* ApplicationLifecycle.Service
-  marks.layers = Date.now()
-  yield* Effect.logInfo("layers ready", { marks })
  const ipc = yield* Ipc.registerIpcHandlers
  if (lifecycle.restoreWindows().length) ipc.installMenu()
-  // The first window's renderer now has its IPC port and is hydrating its stores over it. The crash
-  // reporter (spawns a process) and the context menu (a dependency tree) are not worth answering late.
-  yield* Effect.sleep("500 millis")
-  const logging = yield* DesktopLogging.Service
-  yield* logging.startCrashReporter
  yield* installContextMenu
  yield* Effect.callback<void>((resume) => {
    const quit = () => resume(Effect.void)
@@ -2,10 +2,7 @@
 import { marks } from "./lifecycle/marks"
 import { app } from "electron"
 import { acquireApplicationLock, configureApplication } from "./lifecycle/configure"
-import { startSidecarProbe } from "./service/sidecar-probe"
-import { registerStorageSnapshotHandler } from "./storage/snapshot"
 import { createEarlyWindow } from "./windows/early"
-import { rendererAssetsServed } from "./windows/protocol"
 import { registerRendererScheme } from "./windows/scheme"

 // This module stays small on purpose. Electron holds the ready event until the entry module has
@@ -17,16 +14,10 @@ if (acquireApplicationLock()) {
  registerRendererScheme()
  // Window first, then the bundle: starting the import before ready delays ready itself, because the
  // module graph evaluates on the same thread Chromium needs to finish initialising.
-  void app.whenReady().then(async () => {
+  void app.whenReady().then(() => {
    marks.ready = Date.now()
-    registerStorageSnapshotHandler()
    createEarlyWindow()
    marks.window = Date.now()
-    startSidecarProbe()
-    // The window's renderer is already loading. Its HTML and preloaded chunks are served from this
-    // thread, so the bundle waits for that burst to be answered (or a cap) before it evaluates.
-    if (!process.env.ELECTRON_RENDERER_URL) await rendererAssetsServed({ quietMs: 40, capMs: 400 })
-    marks.served = Date.now()
    return import("./desktop")
  })
 }
@@ -4,7 +4,7 @@ import { EventRpcs } from "../../shared/ipc-rpc"
 import { ipcEventStream } from "../ipc-events"
 import { IpcPortHandoff } from "../ipc-transport"
 import { Shutdown } from "../lifecycle/shutdown"
-import { isRendererUrl } from "../windows/scheme"
+import { isRendererUrl } from "../windows/protocol"
 import { DesktopStorage } from "../storage"
 import { sender } from "./context"

@@ -65,15 +65,12 @@ export const registerIpcHandlers = Effect.gen(function* () {
      if (input.type !== "keyDown" || input.key !== "Escape") return
      win.webContents.send(DragCancelEvent)
    })
-    const post = () => {
+    win.webContents.on("did-finish-load", () => {
      if (win.isDestroyed() || win.webContents.isDestroyed()) return
      const channel = new MessageChannelMain()
      handoff.bind(win.webContents, channel.port1)
      win.webContents.postMessage(IpcTransportPort, null, [channel.port2])
-    }
-    win.webContents.on("did-finish-load", post)
-    // The first window starts loading before the layers exist and may already be done.
-    if (!win.webContents.isLoading() && win.webContents.getURL()) post()
+    })
  }
  yield* Effect.sync(() => {
    app.on("browser-window-created", wire)
@@ -1,6 +1,5 @@
 import { randomUUID } from "node:crypto"
 import { mkdirSync, rmSync } from "node:fs"
-import { enableCompileCache } from "node:module"
 import { homedir, tmpdir } from "node:os"
 import path from "node:path"
 import { app } from "electron"
@@ -32,8 +31,6 @@ export function configureApplication() {
    app.setPath("sessionData", path.join(testRoot, "session"))
    if (testOnboarding) app.setPath("documents", path.join(testRoot, "documents"))
  }
-  // V8 bytecode for the main bundle survives between launches, like the renderer's code cache.
-  enableCompileCache(path.join(app.getPath("userData"), "compile-cache"))
 }

 export function acquireApplicationLock() {
@@ -4,7 +4,6 @@ import { app } from "electron"
 import { Context, Effect, Layer } from "effect"
 import { DesktopLogging } from "../native/logging"
 import { getStore } from "../storage/store"
-import { marks } from "./marks"
 import {
  loadProxyEnvironment,
  preferApplicationEnvironment,
@@ -23,15 +22,12 @@ export const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
    const logging = yield* DesktopLogging.Service
+    yield* prepareApplicationEnvironment
    yield* preferApplicationEnvironment
-    // System certificates, the proxy and the net log serve later network work; the first window and
-    // its IPC port do not wait for them.
-    yield* Effect.forkScoped(
-      prepareApplicationEnvironment.pipe(Effect.andThen(loadProxyEnvironment), Effect.andThen(logging.startNetwork)),
-    )
+    yield* loadProxyEnvironment
    yield* Effect.promise(() => app.whenReady())
+    yield* logging.startNetwork
    yield* prepareDesktop
-    marks.init = Date.now()
    return Service.of({
      version: app.getVersion(),
      updaterStore: getStore("opencode.updater"),
@@ -4,8 +4,7 @@ import { app } from "electron"
 import { Effect, Path } from "effect"
 import { DesktopPaths } from "../paths"
 import { getUserShell, loadShellEnv } from "../service/shell-env"
-import { registerRendererProtocol, setDockIcon, setProtocolReporter } from "../windows"
-import { scoped } from "../native/logging"
+import { registerRendererProtocol, setDockIcon } from "../windows"

 // electron-context-menu attaches to every existing and future window, so it can load once the first
 // window is up instead of holding up startup with its dependency tree.
@@ -38,11 +37,7 @@ export const prepareDesktop = Effect.gen(function* () {
  const paths = yield* DesktopPaths.resolve
  if (app.isPackaged || process.env.OPENCODE_DESKTOP_DISABLE_PROTOCOL_REGISTRATION !== "1")
    app.setAsDefaultProtocolClient("opencode")
-  const runFork = Effect.runForkWith(yield* Effect.context())
-  setProtocolReporter((level, message, data) =>
-    runFork(scoped("protocol", level === "error" ? Effect.logError(message, data) : Effect.logWarning(message, data))),
-  )
-  registerRendererProtocol(paths.rendererRoot)
+  yield* registerRendererProtocol()
  setDockIcon(path, paths)
 })

@@ -9,7 +9,6 @@ import { DesktopLogging, scoped } from "../native/logging"
 import { DesktopStorage } from "../storage"
 import { safeWebContentsURL } from "../windows/state"
 import { getLastFocusedWindow, makeMainWindows, setAppQuitting, setRelaunchHandler } from "../windows"
-import { marks } from "./marks"
 import { initializeFirstLaunchOnboarding } from "./onboarding"
 import { Shutdown } from "./shutdown"

@@ -158,7 +157,6 @@ export const layer = Layer.unwrap(
    // Decide first-launch state before the storage layer creates drafts.sqlite, which would
    // otherwise read as evidence of an earlier launch on a fresh install.
    yield* initializeFirstLaunchOnboarding(app.getPath("userData"))
-    marks.onboarding = Date.now()
    return runtime.pipe(Layer.provideMerge(platform))
  }),
 )
--- a/Show More
+++ b/Show More