perf(desktop): show the previous shell while the renderer boots

The first window now loads its document the moment Electron is ready: the same index.html without its module scripts, plus a sanitized copy of the shell captured at the end of the previous run. The renderer process, the stylesheet and the fonts are ready while the main bundle and the layers load, and the scripts are added when the window is adopted. The renderer asks for its RPC MessagePort instead of receiving one on did-finish-load, since that event fires before the scripts exist. The startup splash and its 300 ms fade are skipped when a snapshot is present; the snapshot is removed when the interface would have been revealed, and re-captured once idle and after route changes.
2026-09-20 15:47:38 +00:00 · 2026-09-19 13:49:56 +10:00
204 changed files with 1379 additions and 3521 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,10 +201,11 @@
    },
    "packages/codemode": {
      "name": "@opencode/codemode",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "acorn": "8.15.0",
        "effect": "catalog:",
+        "typescript": "catalog:",
      },
      "devDependencies": {
        "@tsconfig/bun": "catalog:",
@@ -214,7 +215,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 +251,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 +278,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 +295,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 +319,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 +339,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 +407,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 +456,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 +493,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 +509,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 +528,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 +541,7 @@
    },
    "packages/latex": {
      "name": "@opencode/latex",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -554,7 +555,7 @@
    },
    "packages/merman": {
      "name": "@opencode/merman",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -569,7 +570,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 +609,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 +639,7 @@
    },
    "packages/protocol": {
      "name": "@opencode/protocol",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/schema": "workspace:*",
        "effect": "catalog:",
@@ -653,7 +654,7 @@
    },
    "packages/schema": {
      "name": "@opencode/schema",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@standard-schema/spec": "catalog:",
        "effect": "catalog:",
@@ -677,7 +678,7 @@
    },
    "packages/sdk": {
      "name": "@opencode/sdk",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -698,7 +699,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 +721,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 +756,7 @@
    },
    "packages/simulation": {
      "name": "@opencode/simulation",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/ai": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -775,7 +776,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 +810,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 +829,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 +875,7 @@
    },
    "packages/theme": {
      "name": "@opencode/theme",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opentui/core": "catalog:",
        "effect": "catalog:",
@@ -888,7 +889,7 @@
    },
    "packages/tui": {
      "name": "@opencode/tui",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -923,7 +924,7 @@
    },
    "packages/ui": {
      "name": "@opencode/ui",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@pierre/diffs": "catalog:",
@@ -958,7 +959,7 @@
    },
    "packages/util": {
      "name": "@opencode/util",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "@effect/opentelemetry": "catalog:",
        "@effect/platform-node": "catalog:",
@@ -991,7 +992,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 +1033,7 @@
    },
    "services/update": {
      "name": "@opencode/update",
-      "version": "2.0.11",
+      "version": "2.0.8",
      "dependencies": {
        "jose": "6.0.11",
        "semver": "catalog:",
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-8mOzCscBAuogG4tm8CroqjTX5E5yzCvTobbhKvxQP0U=",
-    "aarch64-linux": "sha256-drrRSpzxC8bfaTXBpOyaN0QAyBVV7WJzm0NstJ+8sAE=",
-    "aarch64-darwin": "sha256-YY5A/zxLPONvgnI+DZlzcD2K5Q9PIw4F2YbDxKbT4UU=",
-    "x86_64-darwin": "sha256-/c/Ew4onA+9+l6GRKXz3zWq3QFESM7j5RyGLCWRPQFw="
+    "x86_64-linux": "sha256-TRfKunG6/UE8rQFyRkx/pX+pe7GT542IJWLEKcFFfAY=",
+    "aarch64-linux": "sha256-JxCYBQoHeJVuEMEe4Ef5f6UxxUCAuhPo96jqMT047Fc=",
+    "aarch64-darwin": "sha256-UEgjeQMivNC7JVsLEDlNbuqp9LJH84f9nHgLHTZ2zDI=",
+    "x86_64-darwin": "sha256-jEs/Oadjf2LVAinY0xyFna0V+NTwoCKXiXmQ83OchF8="
  }
 }
@@ -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])
 }

@@ -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) => {
@@ -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")
  }),
 )

@@ -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": {
@@ -456,10 +456,6 @@ export type V2EventServerConnected = {
  data: {}
 }

-export type ModelSettings = { compaction?: ProviderCompaction } & { [x: string]: any }
-
-export type ConfigModelSettings = { compaction?: ProviderCompaction } & { [x: string]: JsonValue | null }
-
 export type ProviderSettings = {
  timeout?: number | false
  chunkTimeout?: number
@@ -1660,19 +1656,19 @@ export type SessionInboxMove = {
  payload: SessionInboxMovePayload
 }

-export type ModelVariant = {
-  id: string
-  settings?: ModelSettings
-  headers?: { [x: string]: string }
-  body?: { [x: string]: any }
-}
-
 export type ProviderRequest = {
  settings: ProviderSettings
  headers: { [x: string]: string }
  body: { [x: string]: any }
 }

+export type ModelVariant = {
+  id: string
+  settings?: ProviderSettings
+  headers?: { [x: string]: string }
+  body?: { [x: string]: any }
+}
+
 export type ProviderInfo = {
  id: string
  canonical?: string
@@ -1902,7 +1898,7 @@ export type ModelInfo = {
  name: string
  compatibility?: ModelCompatibility
  package?: string
-  settings?: ModelSettings
+  settings?: ProviderSettings
  headers?: { [x: string]: string }
  body?: { [x: string]: any }
  capabilities: ModelCapabilities
@@ -2111,13 +2107,13 @@ export type ConfigEntry =
                name?: string
                compatibility?: ModelCompatibility
                package?: string
-                settings?: ConfigModelSettings
+                settings?: ConfigProviderSettings
                headers?: { [x: string]: string }
                body?: { [x: string]: JsonValue }
                capabilities?: ModelCapabilities
                variants?: Array<{
                  id: string
-                  settings?: ConfigModelSettings
+                  settings?: ConfigProviderSettings
                  headers?: { [x: string]: string }
                  body?: { [x: string]: JsonValue }
                }>
@@ -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

@@ -15,7 +15,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 ## Source and execution model

 - [x] JavaScript parsed with the latest syntax accepted by Acorn, then restricted by the interpreter allowlist.
-      TypeScript-only syntax is rejected rather than stripped before execution.
+- [x] Erasable TypeScript syntax, including type annotations, type declarations, assertions, and non-null assertions.
+      TypeScript is transpiled first; the emitted JavaScript must still use the supported subset.
 - [x] Top-level `await` and `return` through the program's implicit async-function scope.
 - [x] Explicit `return`, final top-level expression as a REPL-style result, and `null` when no value is produced.
 - [x] The host boundary is `JSON.stringify` plus a short table. The program result and tool arguments cross as
@@ -28,7 +29,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.
@@ -40,12 +41,14 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      expression match can still run long on a pathological pattern; the host regex engine has no interrupt hook.
 - [ ] Strict-mode early errors: duplicate parameter names, `yield` as an identifier, and a trailing comma after a
      rest parameter are accepted unless the program itself begins with `"use strict"`.
+- [ ] Valid JavaScript rejected by TypeScript transpilation before interpretation, such as `in` inside a destructuring
+      default in a `for...of` head and Unicode-escaped keywords.

 ## 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 +56,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 +95,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 +127,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 +179,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 +290,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 +305,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 +317,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 +408,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 +424,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 +437,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 +451,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 +461,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
@@ -501,8 +494,9 @@ Nothing is exposed unless a host provides it; extension calls are not tool calls
 - [x] Catchable user throws, runtime failures raised during interpreted evaluation, awaited tool failures, and awaited
      tool-call-limit failures; parse/compile failures, cooperative timeout, and output bounding remain outside program
      `catch`.
- [x] Source locations on unsupported-syntax diagnostics. The diagnostic names the rejected node type and attaches a
-      short orientation to the supported subset; this matrix is the full reference.
+- [x] Source locations on unsupported-syntax diagnostics for JavaScript-shaped input; TypeScript transpilation may
+      shift them. The diagnostic names the rejected node type and attaches a short orientation to the supported
+      subset; this matrix is the full reference.
 - [x] Model-visible host failure messages and underlying causes, including output-validation errors.
 - [x] Caught errors do not distinguish user throws, interpreter failures, and tool failures; a program sees one
      Error-shaped value with `name` and `message` in `catch`, rejection handlers, and `Promise.allSettled` reasons.
@@ -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",
@@ -19,6 +19,12 @@
  "exports": {
    ".": "./src/index.ts"
  },
+  "imports": {
+    "#transpile": {
+      "workerd": "./src/interpreter/transpile.workerd.ts",
+      "default": "./src/interpreter/transpile.node.ts"
+    }
+  },
  "scripts": {
    "build": "bun run script/build.ts",
    "typecheck": "tsgo --noEmit",
@@ -26,7 +32,8 @@
  },
  "dependencies": {
    "acorn": "8.15.0",
-    "effect": "catalog:"
+    "effect": "catalog:",
+    "typescript": "catalog:"
  },
  "devDependencies": {
    "@tsconfig/bun": "catalog:",
@@ -15,7 +15,7 @@ const pkg = JSON.parse(originalText) as {
  name: string
  version: string
  exports: Record<string, string | { import: string; types: string }>
-  imports?: Record<string, Record<string, string>>
+  imports: Record<string, Record<string, string>>
 }
 const tarball = `${pkg.name.replace("@", "").replace("/", "-")}-${pkg.version}.tgz`
 const output = (value: string, types = false) =>
@@ -41,14 +41,12 @@ try {
      ]
    }),
  )
-  if (pkg.imports) {
-    pkg.imports = Object.fromEntries(
-      Object.entries(pkg.imports).map(([key, conditions]) => [
-        key,
-        Object.fromEntries(Object.entries(conditions).map(([condition, value]) => [condition, output(value)])),
-      ]),
-    )
-  }
+  pkg.imports = Object.fromEntries(
+    Object.entries(pkg.imports).map(([key, conditions]) => [
+      key,
+      Object.fromEntries(Object.entries(conditions).map(([condition, value]) => [condition, output(value)])),
+    ]),
+  )
  await Bun.write("package.json", JSON.stringify(pkg, null, 2) + "\n")
  await rm(tarball, { force: true })
  await $`bun pm pack`
@@ -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)
@@ -1,10 +1,14 @@
 import { parse, type Program } from "acorn"
 import { Cause, Effect, Scope } from "effect"
+// #transpile: conditional import — full typescript on node/bun, an identity
+// pass-through on workerd (the compiler is ~11 MiB and can't init there).
+import { transpile } from "#transpile"
 import type { DataValue, Diagnostic, ResolvedExecutionLimits, Result } from "../codemode.js"
 import { toBoundary } from "../data.js"
 import { ToolRuntime } from "../tool-runtime.js"
 import { normalizeError } from "./errors.js"
 import { createBuiltins } from "./intrinsics.js"
+import { PendingThrow } from "./model.js"
 import { Pending } from "./promises.js"
 import { Interpreter } from "./interpreter.js"

@@ -106,7 +110,16 @@ export const executeProgram = <R>(
 }

 const parseProgram = (code: string): Program => {
-  return parse(code, {
+  const transpiled = transpile(`async function __codemode__() {\n${code}\n}`)
+
+  if (transpiled.error !== undefined) {
+    throw new PendingThrow("SyntaxError", `Failed to parse TypeScript: ${transpiled.error}`, undefined, "ParseError")
+  }
+
+  const bodyStart = transpiled.outputText.indexOf("{") + 1
+  const bodyEnd = transpiled.outputText.lastIndexOf("}")
+  const executableCode = transpiled.outputText.slice(bodyStart, bodyEnd)
+  return parse(executableCode, {
    ecmaVersion: "latest",
    sourceType: "script",
    allowReturnOutsideFunction: true,
@@ -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}`
@@ -0,0 +1,25 @@
+import { DiagnosticCategory, ModuleKind, ScriptTarget, flattenDiagnosticMessageText, transpileModule } from "typescript"
+
+export interface TranspileResult {
+  readonly outputText: string
+  readonly error?: string
+}
+
+// Full TypeScript transpilation on node/bun runtimes.
+export const transpile = (source: string): TranspileResult => {
+  const transpiled = transpileModule(source, {
+    reportDiagnostics: true,
+    compilerOptions: {
+      target: ScriptTarget.ESNext,
+      module: ModuleKind.ESNext,
+    },
+  })
+  const diagnostic = transpiled.diagnostics?.find((item) => item.category === DiagnosticCategory.Error)
+  if (diagnostic) {
+    return {
+      outputText: transpiled.outputText,
+      error: flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+    }
+  }
+  return { outputText: transpiled.outputText }
+}
@@ -0,0 +1,11 @@
+export interface TranspileResult {
+  readonly outputText: string
+  readonly error?: string
+}
+
+// workerd profile: the typescript compiler is ~11 MiB and probes node
+// internals at module init, so codemode programs are passed through
+// untranspiled. Plain-JS programs (the overwhelmingly common case) parse
+// fine downstream via acorn; TypeScript-only syntax surfaces as a parse
+// error from the interpreter instead of a transpile diagnostic.
+export const transpile = (source: string): TranspileResult => ({ outputText: source })
@@ -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",
@@ -15,12 +15,6 @@ const error = async (code: string) => {
  return result.error
 }

-describe("source syntax", () => {
-  test("rejects TypeScript-only syntax", async () => {
-    expect((await error(`const value: number = 1; return value`)).kind).toBe("ParseError")
-  })
-})
-
 describe("error identity", () => {
  test("awaiting the same rejected promise twice yields the same error object", async () => {
    expect(
@@ -107,7 +101,7 @@ describe("host errors escaping built-ins", () => {
  test("report the location of the call that raised them", async () => {
    const failure = await error(`return [1].map((n) => n.toFixed(200))`)
    expect(failure.kind).toBe("ExecutionFailure")
-    expect(failure.message).toBe("RangeError: toFixed() argument must be between 0 and 100 (line 1, col 19)")
+    expect(failure.message).toBe("RangeError: toFixed() argument must be between 0 and 100 (line 1, col 23)")
  })

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

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

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

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

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

  test("the limit is 10000 nested calls", async () => {
@@ -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",
@@ -34,7 +34,7 @@ import { Auth, Endpoint, RequestExecutor, type AnyRoute } from "@opencode/ai/rou
 import { ProviderShared } from "@opencode/ai/protocols/shared"
 import { Cause, Context, Effect, Layer, Option, Schema, Scope, Stream } from "effect"
 import { makeParser } from "effect/unstable/encoding/Sse"
-import type { ID, RuntimeInfo } from "./model.js"
+import type { ID, Info } from "./model.js"
 import { Provider } from "./provider.js"
 import { State } from "./state.js"

@@ -46,14 +46,14 @@ type ToolResultContent = Extract<AssistantContent[number], { type: "tool-result"
 const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown))

 export interface SDKEvent {
-  readonly model: RuntimeInfo
+  readonly model: Info
  readonly package: string
  readonly options: Record<string, any>
  sdk?: SDK
 }

 export interface LanguageEvent {
-  readonly model: RuntimeInfo
+  readonly model: Info
  readonly sdk: SDK
  readonly options: Record<string, any>
  language?: LanguageModelV3
@@ -116,7 +116,7 @@ function wrapSSE(res: Response, ms: number, ctl: AbortController) {
  })
 }

-function prepareOptions(model: RuntimeInfo, pkg: string) {
+function prepareOptions(model: Info, pkg: string) {
  const projected = mapBodyToProviderOptions(model, pkg)
  const options: Record<string, any> = {
    name: model.canonical ?? model.providerID,
@@ -182,8 +182,8 @@ export interface Interface {
  }
  readonly runSDK: (event: SDKEvent) => Effect.Effect<SDKEvent>
  readonly runLanguage: (event: LanguageEvent) => Effect.Effect<LanguageEvent>
-  readonly language: (model: RuntimeInfo) => Effect.Effect<LanguageModelV3, InitError>
-  readonly model: (model: RuntimeInfo) => Effect.Effect<LanguageModel, InitError>
+  readonly language: (model: Info) => Effect.Effect<LanguageModelV3, InitError>
+  readonly model: (model: Info) => Effect.Effect<LanguageModel, InitError>
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/AISDK") {}
@@ -302,7 +302,7 @@ export const locationLayer = Layer.effect(
  }),
 )

-function modelFromLanguage(info: RuntimeInfo, language: LanguageModelV3) {
+function modelFromLanguage(info: Info, language: LanguageModelV3) {
  const packageName = Provider.packageName(info.package!)
  const projected = mapBodyToProviderOptions(info, packageName)
  const providerID = info.canonical ?? info.providerID
@@ -399,7 +399,7 @@ function requestSettings(settings: Readonly<Record<string, unknown>> | undefined
  return Object.keys(result).length === 0 ? undefined : result
 }

-function mapBodyToProviderOptions(model: RuntimeInfo, packageName: string) {
+function mapBodyToProviderOptions(model: Info, packageName: string) {
  const settings = requestSettings(model.settings)
  const pro = Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(model.body?.reasoning)
  const forceReasoning =
@@ -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 []
@@ -8,7 +8,6 @@ import { AISDK } from "./aisdk.js"
 import { Credential } from "./credential.js"
 import { Integration } from "./integration.js"
 import { Capabilities, ID, Info, Model, Ref, VariantID } from "./model.js"
-import type { RuntimeInfo } from "./model.js"
 import { Npm } from "@opencode/util/npm"
 import { Provider } from "./provider.js"

@@ -118,9 +117,9 @@ export interface Resolved {
  readonly cost: Info["cost"]
  /** Catalog token limits used by Core for context management. */
  readonly limit: Info["limit"]
-  /** Model policy overrides the provider policy; omitted means summary compaction. */
+  /** Model policy overrides the provider policy; omitted means local compaction. */
  readonly compaction?: Provider.Compaction
-  /** Provider transport policy; omitted means HTTP. */
+  /** Model transport overrides the provider transport; omitted means HTTP. */
  readonly transport?: Provider.Transport
 }

@@ -150,7 +149,7 @@ export const withVariant = (
    variant
      ? {
          ...model,
-          settings: Provider.mergeOverlay(model.settings, Provider.modelSettings(variant.settings)),
+          settings: Provider.mergeOverlay(model.settings, variant.settings),
          headers: Provider.mergeHeaders(model.headers, variant.headers),
          body: Provider.mergeOverlay(model.body, variant.body),
        }
@@ -160,11 +159,11 @@ export const withVariant = (

 export interface Dependencies {
  readonly loadPackage?: (specifier: string) => Effect.Effect<Provider.ProviderPackage, Provider.LoadError>
-  readonly loadAISDK?: (model: RuntimeInfo) => Effect.Effect<LanguageModel, AISDK.InitError>
+  readonly loadAISDK?: (model: Info) => Effect.Effect<LanguageModel, AISDK.InitError>
 }

 export const fromCatalogModel = (
-  model: RuntimeInfo,
+  model: Info,
  credential?: Credential.Value,
  dependencies?: Dependencies,
 ): Effect.Effect<
@@ -192,7 +191,7 @@ export const fromCatalogModel = (
  )

 const resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(function* (
-  model: RuntimeInfo,
+  model: Info,
  credential?: Credential.Value,
  dependencies?: Dependencies,
 ) {
@@ -249,7 +248,7 @@ const resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(funct
  })
 })

-function prepareRuntimeModel(model: RuntimeInfo, credential: Credential.Value | undefined) {
+function prepareRuntimeModel(model: Info, credential: Credential.Value | undefined) {
  if (model.settings?.apiKey !== "" && (credential?.type !== "key" || credential.metadata === undefined)) return model
  return {
    ...model,
@@ -261,7 +260,7 @@ function prepareRuntimeModel(model: RuntimeInfo, credential: Credential.Value |
 }

 function validateProviderVariables(
-  model: RuntimeInfo,
+  model: Info,
  resolved: LanguageModel,
 ): Effect.Effect<LanguageModel, UnresolvedProviderVariablesError> {
  const baseURL = resolved.route.endpoint.baseURL
@@ -271,7 +270,7 @@ function validateProviderVariables(
 }

 function prepareProviderSettings(
-  model: RuntimeInfo,
+  model: Info,
  settings: Readonly<Record<string, unknown>>,
 ): Effect.Effect<Readonly<Record<string, unknown>>, UnresolvedProviderVariablesError> {
  const baseURL = settings.baseURL
@@ -281,14 +280,14 @@ function prepareProviderSettings(
  )
 }

-function prepareProviderURL(model: RuntimeInfo, baseURL: string): Effect.Effect<string, UnresolvedProviderVariablesError> {
+function prepareProviderURL(model: Info, baseURL: string): Effect.Effect<string, UnresolvedProviderVariablesError> {
  if (!baseURL.includes("${")) return Effect.succeed(baseURL)
  const prepared = baseURL.replace(/\$\{([^}]+)\}/g, (placeholder, name: string) => process.env[name] ?? placeholder)
  const failure = unresolvedProviderVariables(model, prepared)
  return failure ? Effect.fail(failure) : Effect.succeed(prepared)
 }

-function unresolvedProviderVariables(model: RuntimeInfo, baseURL: string) {
+function unresolvedProviderVariables(model: Info, baseURL: string) {
  const variables = new Set(Array.from(baseURL.matchAll(/\$\{([^}]+)\}/g), (match) => match[1]))
  if (variables.size === 0) return
  return new UnresolvedProviderVariablesError({
@@ -311,14 +310,14 @@ const nativeCredentialSettings = (specifier: string, credential: Credential.Valu
  return { apiKey: credential.access }
 }

-const unsupported = (model: RuntimeInfo) =>
+const unsupported = (model: Info) =>
  new UnsupportedPackageError({
    providerID: model.providerID,
    modelID: model.id,
    package: model.package ?? "unknown",
  })

-const initialization = (model: RuntimeInfo, phase: InitializationPhase, cause: unknown) =>
+const initialization = (model: Info, phase: InitializationPhase, cause: unknown) =>
  new ModelInitializationError({
    providerID: model.providerID,
    modelID: model.id,
@@ -360,11 +359,7 @@ export const layer = Layer.effect(
        provider?.integrationID ?? Integration.ID.make(selected.providerID),
      )
      const credential = connection ? yield* integrations.connection.resolve(connection) : undefined
-      const selectedVariant = yield* withVariant(selected, variant)
-      const runtimeInfo: RuntimeInfo = {
-        ...selectedVariant,
-        settings: Provider.mergeOverlay(provider?.settings, Provider.modelSettings(selectedVariant.settings)),
-      }
+      const runtimeInfo = yield* withVariant(selected, variant)
      const model = yield* fromCatalogModel(runtimeInfo, credential, {
        loadPackage: (specifier) => Provider.loadPackage(specifier, npm),
        loadAISDK: (model) => aisdk.model(model),
@@ -387,7 +382,7 @@ export const layer = Layer.effect(
        cost: selected.cost,
        limit: selected.limit,
        compaction: runtimeInfo.settings?.compaction,
-        transport: provider?.settings?.transport,
+        transport: runtimeInfo.settings?.transport,
      }
    })
    return Service.of({
@@ -411,7 +406,7 @@ export const layer = Layer.effect(
  }),
 )

-function hasConfiguredAuth(model: RuntimeInfo) {
+function hasConfiguredAuth(model: Info) {
  return [model.settings?.apiKey, model.settings?.authToken, model.settings?.accessToken].some(
    (value) => typeof value === "string" && value !== "",
  )
@@ -36,9 +36,6 @@ export type Ref = typeof Ref.Type
 export const Info = Model.Info
 export type Info = Model.Info

-/** Effective provider and model settings used only while constructing a runtime model. */
-export type RuntimeInfo = Omit<Info, "settings"> & { readonly settings?: Provider.Settings }
-
 export type MutableInfo = DeepMutable<Info>

 export { Event } from "@opencode/schema/model"
@@ -191,10 +188,7 @@ const layer = Layer.effect(
                    ...model,
                    ...(provider?.canonical === undefined ? {} : { canonical: provider.canonical }),
                    package: model.package ?? provider?.package,
-                    settings: Provider.mergeOverlay(
-                      Provider.modelSettings(provider?.settings),
-                      Provider.modelSettings(model.settings),
-                    ),
+                    settings: Provider.mergeOverlay(provider?.settings, model.settings),
                    headers: Provider.mergeHeaders(provider?.headers, model.headers),
                    body: Provider.mergeOverlay(provider?.body, model.body),
                  } satisfies Info
@@ -208,12 +202,7 @@ const layer = Layer.effect(
        const all = Array.from(byProvider.values())
          .flatMap((models) => Array.from(models.values()))
          .sort((left, right) => right.time.released - left.time.released)
-        const requested = data.defaultModel
-        const preferred = requested && byProvider.get(requested.providerID)?.get(requested.modelID)
-        const available = preferred?.enabled
-          ? [preferred, ...all.filter((model) => model.enabled && model !== preferred)]
-          : all.filter((model) => model.enabled)
-        cached = freeze({ data, all, available, byProvider }, true)
+        cached = freeze({ data, all, available: all.filter((model) => model.enabled), byProvider }, true)
        return cached
      }
    })
@@ -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)
  }),
 })

@@ -7,6 +7,7 @@ import { App } from "../../app.js"
 import { Bus } from "../../bus.js"
 import { Credential } from "../../credential.js"
 import { Integration } from "../../integration.js"
+import { Model } from "../../model.js"
 import { Provider } from "../../provider.js"
 import { iife } from "../../util/iife.js"
 import { which } from "../../util/which.js"
@@ -139,18 +140,16 @@ export const AzurePlugin = define({
        )
          continue
        const resourceName = resolveResourceName(item.provider.settings, loaded.resource)
-        const websocket = responsesWebSocketCapable(item.provider)
-        if (!resourceName && !websocket) continue
-        evt.update(item.provider.id, (provider) => {
-          provider.settings = {
-            ...provider.settings,
-            ...(resourceName === undefined ? {} : { resourceName }),
-            ...(websocket ? { transport: provider.settings?.transport ?? "websocket" } : {}),
-            ...(resourceName !== undefined && typeof provider.settings?.baseURL === "string"
-              ? { baseURL: expandResourceName(provider.settings.baseURL, resourceName) }
-              : {}),
-          }
-        })
+        if (resourceName)
+          evt.update(item.provider.id, (provider) => {
+            provider.settings = {
+              ...provider.settings,
+              resourceName,
+              ...(typeof provider.settings?.baseURL === "string"
+                ? { baseURL: expandResourceName(provider.settings.baseURL, resourceName) }
+                : {}),
+            }
+          })
      }
    })
    yield* ctx.model.transform((models) => {
@@ -168,6 +167,10 @@ export const AzurePlugin = define({
                draft.settings.baseURL,
                resolveResourceName(draft.settings, resourceName) ?? resourceName,
              )
+            if (responsesWebSocketCapable(item.provider, draft))
+              draft.settings = Provider.mergeOverlay(draft.settings, {
+                transport: item.provider.settings?.transport ?? "websocket",
+              })
          })
        }
      }
@@ -239,9 +242,9 @@ function expandResourceName(baseURL: string, resourceName: string) {
    .replaceAll("${AZURE_COGNITIVE_SERVICES_RESOURCE_NAME}", resourceName)
 }

-function responsesWebSocketCapable(provider: Provider.Info) {
-  if (provider.package !== "@opencode/ai/providers/azure/responses") return false
-  const settings = provider.settings
+function responsesWebSocketCapable(provider: Provider.Info, model: Model.Info) {
+  if ((model.package ?? provider.package) !== "@opencode/ai/providers/azure/responses") return false
+  const settings = Provider.mergeOverlay(provider.settings, model.settings)
  if (settings?.useDeploymentBasedUrls === true) return false
  if (settings?.apiVersion !== undefined && settings.apiVersion !== "v1") return false
  if (typeof settings?.baseURL !== "string") return true
@@ -254,13 +254,10 @@ export const OpenAIPlugin = define({
    yield* ctx.provider.transform((providers) => {
      const item = providers.get(Provider.ID.openai)
      if (!item) return
-      const account = chatgpt?.metadata?.accountID
+      if (!chatgpt) return
+      const account = chatgpt.metadata?.accountID
      providers.update(item.provider.id, (provider) => {
-        provider.settings = Provider.mergeOverlay(provider.settings, {
-          transport: provider.settings?.transport ?? "websocket",
-          ...(chatgpt ? { baseURL: codexBaseURL } : {}),
-        })
-        if (!chatgpt) return
+        provider.settings = Provider.mergeOverlay(provider.settings, { baseURL: codexBaseURL })
        provider.headers = Provider.mergeHeaders(provider.headers, {
          originator: "opencode",
          "x-codex-beta-features": "remote_compaction_v2",
@@ -273,6 +270,9 @@ export const OpenAIPlugin = define({
        // ChatGPT-plan tokens only authorize codex-eligible models, and the
        // subscription covers usage, so hide the rest and zero the cost.
        models.update(model.providerID, model.id, (draft) => {
+          draft.settings = Provider.mergeOverlay(draft.settings, {
+            transport: models.provider.get(model.providerID)?.provider.settings?.transport ?? "websocket",
+          })
          if (!chatgpt) return
          if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(draft.body?.reasoning)) {
            draft.enabled = false
@@ -7,14 +7,12 @@ import { Bus } from "../../bus.js"
 import { Credential } from "../../credential.js"
 import { Integration } from "../../integration.js"
 import { IntegrationConnection } from "../../integration/connection.js"
-import { Model } from "../../model.js"
 import { Provider } from "../../provider.js"
 import { WebSearch } from "../../websearch.js"
 import { ConfigProvider } from "@opencode/schema/config/provider"
 import { Money } from "@opencode/schema/money"

 const defaultServer = "https://opencode.ai/console"
-const publicDefaultModelID = Model.ID.make("big-pickle")
 const clientID = "opencode-cli"
 const methodID = Integration.MethodID.make("device")
 const RemoteResponse = Schema.Struct({
@@ -257,9 +255,6 @@ export const OpencodePlugin = define<HttpClient.HttpClient | Bus.Service | Scope
          draft.enabled = false
        })
      }
-      if (models.get(item.provider.id, publicDefaultModelID)?.enabled) {
-        models.default.set(item.provider.id, publicDefaultModelID)
-      }
    })

    yield* ctx.websearch.transform((editor) => {
@@ -95,13 +95,14 @@ export const XAIPlugin = define({
      editor.method.update(device(ctx.app))
      editor.method.update({ integrationID: "xai", method: { type: "key", label: "Manually enter API Key" } })
    })
-    yield* ctx.provider.transform((providers) => {
-      if (!providers.get(providerID)) return
-      providers.update(providerID, (provider) => {
-        provider.settings = Provider.mergeOverlay(provider.settings, {
-          transport: provider.settings?.transport ?? "websocket",
+    yield* ctx.model.transform((models) => {
+      for (const model of models.list(providerID)) {
+        models.update(providerID, model.id, (draft) => {
+          draft.settings = Provider.mergeOverlay(draft.settings, {
+            transport: models.provider.get(providerID)?.provider.settings?.transport ?? "websocket",
+          })
        })
-      })
+      }
    })
  }),
 })
@@ -134,16 +134,11 @@ export const loadPackage = Effect.fn("Provider.loadPackage")(function* (input: s

 /** opencode settings consumed in Core; native packages never receive them. */
 const CORE_KEYS = ["chunkTimeout", "compaction", "fetch", "timeout", "transport"] as const
-const PROVIDER_ONLY_KEYS = ["chunkTimeout", "timeout", "transport"] as const

 export function nativeSettings(settings: Settings): Settings {
  return Struct.omit(settings, CORE_KEYS)
 }

-export function modelSettings(settings: Settings | undefined) {
-  return settings && Struct.omit(settings, PROVIDER_ONLY_KEYS)
-}
-
 export function mergeOverlay(
  base: Readonly<Record<string, unknown>> | undefined,
  overlay: Readonly<Record<string, unknown>> | undefined,
@@ -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
              ? []
@@ -27,15 +27,14 @@ import { testEffect } from "./lib/effect"

 const it = testEffect(AISDK.locationLayer)

-const model = (packageName: string, settings: Provider.Settings = {}): Model.RuntimeInfo => ({
-  ...Model.Info.make({
+const model = (packageName: string, settings: Record<string, unknown> = {}) =>
+  Model.Info.make({
    ...Model.Info.default(Provider.ID.make("test-provider"), Model.ID.make("catalog-model")),
    modelID: Model.ID.make("api-model"),
    package: Provider.aisdk(packageName),
+    settings,
    limit: { context: 100, output: 20 },
-  }),
-  settings,
-})
+  })

 const streamModel = (events: ReadonlyArray<LanguageModelV3StreamPart>): LanguageModelV3 => ({
  specificationVersion: "v3",
@@ -511,7 +511,7 @@ describe("Provider and Model", () => {
    }),
  )

-  it.effect("keeps settings scoped while resolving request overlay merges", () =>
+  it.effect("resolves provider and model overlay merges", () =>
    Effect.gen(function* () {
      const providers = yield* Provider.Service
      const models = yield* Model.Service
@@ -533,7 +533,6 @@ describe("Provider and Model", () => {
      })

      const model = required(yield* models.get(providerID, modelID))
-      expect((yield* providers.get(providerID))?.settings).toEqual({ provider: true, shared: "provider" })
      expect(model.settings).toEqual({ provider: true, shared: "model", model: true })
      expect(model.headers).toEqual({ provider: "provider", shared: "model", model: "model" })
      expect(model.body).toEqual({ provider: true, shared: "model", model: true })
@@ -37,7 +37,6 @@ describe("ConfigProviderPlugin.Plugin", () => {
  it.effect("inherits the provider compaction setting with model overrides and rejects unsupported routes", () =>
    Effect.gen(function* () {
      const models = yield* Model.Service
-      const providers = yield* Provider.Service
      yield* addPlugin([
        new Document({
          type: "document",
@@ -64,7 +63,6 @@ describe("ConfigProviderPlugin.Plugin", () => {
      expect(native.settings?.compaction).toEqual({ type: "native" })
      expect(local.settings?.compaction).toEqual({ type: "summary" })
      expect(defaultModel.settings?.compaction).toBeUndefined()
-      expect((yield* providers.get(Provider.ID.make("custom")))?.settings?.compaction).toEqual({ type: "native" })
      yield* ModelResolver.fromCatalogModel(native)
      yield* ModelResolver.fromCatalogModel(local)
      yield* ModelResolver.fromCatalogModel(defaultModel)
@@ -75,9 +73,8 @@ describe("ConfigProviderPlugin.Plugin", () => {
    }),
  )

-  it.effect("keeps the provider websocket policy out of model settings", () =>
+  it.effect("inherits the provider websocket policy with model overrides", () =>
    Effect.gen(function* () {
-      const providers = yield* Provider.Service
      const models = yield* Model.Service
      yield* addPlugin([
        new Document({
@@ -86,12 +83,8 @@ describe("ConfigProviderPlugin.Plugin", () => {
            providers: {
              custom: {
                package: "@opencode/ai/providers/openai/responses",
-                settings: { transport: "http", timeout: 100, chunkTimeout: 200, shared: "provider" },
-                models: {
-                  inherited: {
-                    settings: { transport: "websocket", timeout: 1, chunkTimeout: 2, model: true },
-                  },
-                },
+                settings: { transport: "http" },
+                models: { inherited: {}, override: { settings: { transport: "websocket" } } },
              },
              default: { package: "@opencode/ai/providers/openai/responses", models: { untouched: {} } },
            },
@@ -99,9 +92,10 @@ describe("ConfigProviderPlugin.Plugin", () => {
        }),
      ])
      const inherited = required(yield* models.get(Provider.ID.make("custom"), Model.ID.make("inherited")))
+      const override = required(yield* models.get(Provider.ID.make("custom"), Model.ID.make("override")))
      const untouched = required(yield* models.get(Provider.ID.make("default"), Model.ID.make("untouched")))
-      expect((yield* providers.get(Provider.ID.make("custom")))?.settings?.transport).toBe("http")
-      expect(inherited.settings).toEqual({ shared: "provider", model: true })
+      expect(inherited.settings?.transport).toBe("http")
+      expect(override.settings?.transport).toBe("websocket")
      expect(untouched.settings?.transport).toBeUndefined()
    }),
  )
@@ -112,7 +106,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
    { id: "azure", model: "gpt-5.6-sol", package: "@opencode/ai/providers/azure/responses", plugin: AzurePlugin },
    { id: "custom-azure", model: "deployment", package: "@opencode/ai/providers/azure/responses", plugin: AzurePlugin },
  ]) {
-    it.live(`configured provider transport overrides ${builtin.id} defaults`, () =>
+    it.live(`provider transport overrides ${builtin.id} defaults while model overrides still win`, () =>
      Effect.gen(function* () {
        const providers = yield* Provider.Service
        const models = yield* Model.Service
@@ -128,8 +122,7 @@ describe("ConfigProviderPlugin.Plugin", () => {
          editor.models.update(providerID, modelID, () => {})
        })
        yield* builtin.plugin.effect(host)
-        expect((yield* providers.get(providerID))?.settings?.transport).toBe("websocket")
-        expect((yield* models.get(providerID, modelID))?.settings?.transport).toBeUndefined()
+        expect((yield* models.get(providerID, modelID))?.settings?.transport).toBe("websocket")

        yield* addPlugin([
          new Document({
@@ -138,16 +131,15 @@ describe("ConfigProviderPlugin.Plugin", () => {
              providers: {
                [builtin.id]: {
                  settings: { transport: "http" },
-                  models: { override: { modelID: builtin.model } },
+                  models: { override: { modelID: builtin.model, settings: { transport: "websocket" } } },
                },
              },
            }),
          }),
        ])

-        expect((yield* providers.get(providerID))?.settings?.transport).toBe("http")
-        expect((yield* models.get(providerID, modelID))?.settings?.transport).toBeUndefined()
-        expect((yield* models.get(providerID, Model.ID.make("override")))?.settings?.transport).toBeUndefined()
+        expect((yield* models.get(providerID, modelID))?.settings?.transport).toBe("http")
+        expect((yield* models.get(providerID, Model.ID.make("override")))?.settings?.transport).toBe("websocket")
      }),
    )
  }
@@ -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
@@ -434,7 +434,7 @@ describe("AzurePlugin", () => {
    ),
  )

-  it.effect("stores the Azure Responses WebSocket preference on the provider", () =>
+  it.effect("marks only Azure v1 Responses deployments as WebSocket capable", () =>
    withEnv({ AZURE_RESOURCE_NAME: undefined, AZURE_COGNITIVE_SERVICES_RESOURCE_NAME: undefined }, () =>
      Effect.gen(function* () {
        const catalog = yield* Provider.Service
@@ -472,8 +472,9 @@ describe("AzurePlugin", () => {

        yield* addPlugin()

-        expect((yield* catalog.get(Provider.ID.azure))?.settings?.transport).toBe("websocket")
-        for (const modelID of [models.responses, models.chat, models.preview, models.deploymentURL, models.gateway, models.nonAzure]) {
+        const responses = required(yield* service.get(Provider.ID.azure, models.responses))
+        expect(responses.settings?.transport).toBe("websocket")
+        for (const modelID of [models.chat, models.preview, models.deploymentURL, models.gateway, models.nonAzure]) {
          const model = required(yield* service.get(Provider.ID.azure, modelID))
          expect(model.settings?.transport).toBeUndefined()
        }
@@ -205,8 +205,7 @@ describe("OpenAIPlugin", () => {
      expect(model.package).toBe("@opencode/ai/providers/openai")
      expect(model.enabled).toBe(true)
      expect(model.limit).toEqual({ context: 1_050_000, input: 922_000, output: 128_000 })
-      expect(provider.settings?.transport).toBe("websocket")
-      expect(model.settings?.transport).toBeUndefined()
+      expect(model.settings?.transport).toBe("websocket")
      expect(direct.headers).not.toHaveProperty("originator")
      expect(direct.baseURL).toBe("https://api.openai.com/v1")
      expect(provider.headers).not.toHaveProperty("x-codex-beta-features")
@@ -1122,29 +1122,6 @@ describe("OpencodePlugin", () => {
    ),
  )

-  it.effect("defaults public users to Big Pickle", () =>
-    withEnv({ OPENCODE_API_KEY: undefined }, () =>
-      Effect.gen(function* () {
-        const catalog = yield* Provider.Service
-        const models = yield* Model.Service
-        yield* catalog.transform((catalog) => {
-          catalog.update(Provider.ID.opencode, () => {})
-          catalog.models.update(Provider.ID.opencode, Model.ID.make("jev-1.13-free"), (draft) => {
-            draft.cost = cost(0)
-            draft.time.released = Date.UTC(2026, 8, 15)
-          })
-          catalog.models.update(Provider.ID.opencode, Model.ID.make("big-pickle"), (draft) => {
-            draft.cost = cost(0)
-            draft.time.released = Date.UTC(2025, 9, 17)
-          })
-        })
-        yield* addPlugin()
-        expect((yield* models.default())?.id).toBe(Model.ID.make("big-pickle"))
-        expect((yield* models.available())[0]?.id).toBe(Model.ID.make("big-pickle"))
-      }),
-    ),
-  )
-
  it.effect("treats output-only cost as free without credentials", () =>
    withEnv({ OPENCODE_API_KEY: undefined }, () =>
      Effect.gen(function* () {
@@ -83,10 +83,8 @@ describe("XAIPlugin", () => {

      yield* addPlugin()

-      const provider = yield* providers.get(providerID)
      const model = yield* models.get(providerID, Model.ID.make("grok-4.6"))
-      expect(provider?.settings?.transport).toBe("websocket")
-      expect(model?.settings?.transport).toBeUndefined()
+      expect(model?.settings?.transport).toBe("websocket")
    }),
  )
 })
@@ -42,19 +42,4 @@ describe("Provider", () => {
      reasoningEffort: "high",
    })
  })
-
-  test("inherits shared and loose settings without provider-only policies", () => {
-    expect(
-      Provider.modelSettings({
-        timeout: 60_000,
-        chunkTimeout: 30_000,
-        transport: "websocket",
-        compaction: { type: "native" },
-        reasoningEffort: "high",
-      }),
-    ).toEqual({
-      compaction: { type: "native" },
-      reasoningEffort: "high",
-    })
-  })
 })
@@ -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])))
  })
 })
--- a/Show More
+++ b/Show More