chore(core): refresh bundled models.dev snapshot

feat(codemode): add toLocaleString, Error.isError, and Map.getOrInsert (#50098 )
2026-09-20 15:47:38 +00:00 · 2026-09-20 15:37:06 +00:00 · 2026-09-20 10:23:23 -05:00 · 2026-09-20 14:37:06 +00:00 · 2026-09-20 13:36:51 +00:00 · 2026-09-20 12:43:39 +00:00
142 changed files with 1929 additions and 797 deletions
@@ -32,7 +32,7 @@
    },
    "packages/ai": {
      "name": "@opencode/ai",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@aws-sdk/credential-providers": "3.1057.0",
        "@opencode/schema": "workspace:*",
@@ -54,7 +54,7 @@
    },
    "packages/app": {
      "name": "@opencode/app",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@corvu/drawer": "catalog:",
        "@dnd-kit/abstract": "0.5.0",
@@ -111,7 +111,7 @@
    },
    "packages/cli": {
      "name": "@opencode/cli",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "bin": {
        "opencode2": "./bin/opencode2.cjs",
      },
@@ -175,7 +175,7 @@
    },
    "packages/client": {
      "name": "@opencode/client",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@opencode/protocol": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -201,7 +201,7 @@
    },
    "packages/codemode": {
      "name": "@opencode/codemode",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "acorn": "8.15.0",
        "effect": "catalog:",
@@ -214,7 +214,7 @@
    },
    "packages/console/app": {
      "name": "@opencode/console-app",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@ibm/plex": "6.4.1",
@@ -250,7 +250,7 @@
    },
    "packages/console/core": {
      "name": "@opencode/console-core",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@aws-sdk/client-sts": "3.782.0",
        "@jsx-email/render": "1.1.1",
@@ -277,7 +277,7 @@
    },
    "packages/console/function": {
      "name": "@opencode/console-function",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@openauthjs/openauth": "0.0.0-20250322224806",
        "@opencode/console-core": "workspace:*",
@@ -294,7 +294,7 @@
    },
    "packages/console/mail": {
      "name": "@opencode/console-mail",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@jsx-email/all": "2.2.3",
        "@jsx-email/cli": "1.4.3",
@@ -318,7 +318,7 @@
    },
    "packages/console/support": {
      "name": "@opencode/console-support",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@opencode/console-core": "workspace:*",
@@ -338,7 +338,7 @@
    },
    "packages/core": {
      "name": "@opencode/core",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@ai-sdk/cohere": "3.0.27",
        "@ai-sdk/gateway": "3.0.104",
@@ -406,7 +406,7 @@
    },
    "packages/desktop": {
      "name": "@opencode/desktop",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@zip.js/zip.js": "2.7.62",
        "electron-context-menu": "4.1.2",
@@ -455,7 +455,7 @@
    },
    "packages/enterprise": {
      "name": "@opencode/enterprise",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@hono/standard-validator": "catalog:",
        "@opencode-ai/sdk": "1.18.21",
@@ -492,7 +492,7 @@
    },
    "packages/function": {
      "name": "@opencode/function",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@octokit/auth-app": "8.0.1",
        "@octokit/rest": "catalog:",
@@ -508,7 +508,7 @@
    },
    "packages/http-recorder": {
      "name": "@opencode/http-recorder",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@effect/platform-node-shared": "4.0.0-rc.112",
      },
@@ -527,7 +527,7 @@
    },
    "packages/httpapi-codegen": {
      "name": "@opencode/httpapi-codegen",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "effect": "catalog:",
        "prettier": "3.6.2",
@@ -540,7 +540,7 @@
    },
    "packages/latex": {
      "name": "@opencode/latex",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -554,7 +554,7 @@
    },
    "packages/merman": {
      "name": "@opencode/merman",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -569,7 +569,7 @@
    },
    "packages/plugin": {
      "name": "@opencode/plugin",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@ai-sdk/provider": "3.0.8",
        "@opencode/ai": "workspace:*",
@@ -608,7 +608,7 @@
    },
    "packages/plugin-browser": {
      "name": "@opencode/plugin-browser",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -638,7 +638,7 @@
    },
    "packages/protocol": {
      "name": "@opencode/protocol",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@opencode/schema": "workspace:*",
        "effect": "catalog:",
@@ -653,7 +653,7 @@
    },
    "packages/schema": {
      "name": "@opencode/schema",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@standard-schema/spec": "catalog:",
        "effect": "catalog:",
@@ -677,7 +677,7 @@
    },
    "packages/sdk": {
      "name": "@opencode/sdk",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -698,7 +698,7 @@
    },
    "packages/server": {
      "name": "@opencode/server",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@effect/platform-node": "catalog:",
        "@effect/platform-node-shared": "catalog:",
@@ -720,7 +720,7 @@
    },
    "packages/session-ui": {
      "name": "@opencode/session-ui",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode/client": "workspace:*",
@@ -755,7 +755,7 @@
    },
    "packages/simulation": {
      "name": "@opencode/simulation",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@opencode/ai": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -775,7 +775,7 @@
    },
    "packages/stats/app": {
      "name": "@opencode/stats-app",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@ibm/plex": "6.4.1",
        "@kobalte/core": "catalog:",
@@ -809,7 +809,7 @@
    },
    "packages/stats/core": {
      "name": "@opencode/stats-core",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@aws-sdk/client-athena": "3.933.0",
        "@planetscale/database": "1.19.0",
@@ -828,7 +828,7 @@
    },
    "packages/stats/server": {
      "name": "@opencode/stats-server",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@aws-sdk/client-firehose": "3.933.0",
        "@effect/platform-node": "catalog:",
@@ -874,7 +874,7 @@
    },
    "packages/theme": {
      "name": "@opencode/theme",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@opentui/core": "catalog:",
        "effect": "catalog:",
@@ -888,7 +888,7 @@
    },
    "packages/tui": {
      "name": "@opencode/tui",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -923,7 +923,7 @@
    },
    "packages/ui": {
      "name": "@opencode/ui",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@pierre/diffs": "catalog:",
@@ -958,7 +958,7 @@
    },
    "packages/util": {
      "name": "@opencode/util",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@effect/opentelemetry": "catalog:",
        "@effect/platform-node": "catalog:",
@@ -991,7 +991,7 @@
    },
    "packages/web": {
      "name": "@opencode/web",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "@astrojs/cloudflare": "12.6.3",
        "@astrojs/markdown-remark": "6.3.1",
@@ -1032,7 +1032,7 @@
    },
    "services/update": {
      "name": "@opencode/update",
-      "version": "2.0.10",
+      "version": "2.0.11",
      "dependencies": {
        "jose": "6.0.11",
        "semver": "catalog:",
@@ -2,7 +2,7 @@
  "$schema": "https://json.schemastore.org/package.json",
  "name": "opencode",
  "description": "AI-powered development tool",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "private": true,
  "type": "module",
  "packageManager": "bun@1.4.2",
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "name": "@opencode/ai",
  "type": "module",
  "license": "MIT",
@@ -73,11 +73,6 @@ 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) => event.code || event.error?.code || event.response?.error?.code || undefined
+const code = (event: OpenResponses.Event) => OpenResponses.errorDetail(event).code

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

-// Responses-compatible providers put streaming error details at the top level or
-// under `error`, and response failures under `response.error`. Accept all three shapes.
+// 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.
 // https://www.openresponses.org/specification
-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,
-  })
+const asText = (value: unknown) =>
+  typeof value === "string" && value.length > 0 ? value : typeof value === "number" ? String(value) : undefined

 export const Event = Schema.StructWithRest(
  Schema.Struct({
@@ -400,31 +360,18 @@ 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: optionalNull(OpenResponsesErrorPayload),
+          error: Schema.optional(Schema.Unknown),
        }),
        [Schema.Record(Schema.String, Schema.Unknown)],
      ),
    ),
-    code: optionalNull(Schema.String),
-    message: Schema.optional(Schema.String),
-    param: optionalNull(Schema.String),
-    error: optionalNull(OpenResponsesErrorPayload),
+    code: Schema.optional(Schema.Unknown),
+    message: Schema.optional(Schema.Unknown),
+    error: Schema.optional(Schema.Unknown),
    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 }
@@ -433,16 +380,15 @@ const decodeEventValue = Schema.decodeUnknownEffect(Event)
 const decodeFrame = Schema.decodeUnknownEffect(ProviderShared.Json)

 /**
- * 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.
+ * 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.
 */
 export const decodeChannelEvent = (frame: string) =>
  decodeFrame(frame).pipe(
    Effect.flatMap((value) =>
      decodeEventValue(
-        ProviderShared.isRecord(value) &&
-          value.type === undefined &&
-          (typeof value.error === "string" || ProviderShared.isRecord(value.error))
+        ProviderShared.isRecord(value) && value.type === undefined && value.error != null
          ? { ...value, type: "error" }
          : value,
      ),
@@ -1422,22 +1368,21 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
  return [{ ...current, lifecycle }, events] satisfies StepResult
 })

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

+// 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 nested = event.error ?? event.response?.error ?? undefined
-  const summary = providerErrorMessage(event, nested)
+  const detail = errorDetail(event)
+  const summary = detail.message && detail.code ? `${detail.code}: ${detail.message}` : (detail.message ?? detail.code)
  const message = summary ?? (body === "{}" ? fallback : body)
  const status =
    typeof event.status === "number"
@@ -1520,18 +1465,7 @@ 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 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`)),
-    )
+  if (event.type === "error") return providerFailure(event, `${state.name} stream error`)
  return Effect.succeed<StepResult>([state, NO_EVENTS])
 }

@@ -215,7 +215,9 @@ export const fromWebSocket = (
 ): Effect.Effect<WebSocketConnection, AIError> =>
  Effect.gen(function* () {
    yield* waitOpen(ws, input)
-    const messages = yield* Queue.bounded<string | Uint8Array, AIError | Cause.Done<void>>(128)
+    // 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 oversized = (message: string | Uint8Array) =>
      typeof message === "string" ? new Blob([message]).size > MAX_FRAME_BYTES : message.byteLength > MAX_FRAME_BYTES
@@ -238,19 +240,7 @@ export const fromWebSocket = (
    }
    const offer = (message: string | Uint8Array) => {
      if (rejectOversized(message)) return
-      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",
-          }),
-        ),
-      )
+      Queue.offerUnsafe(messages, message)
    }

    const onMessage = (event: MessageEvent) => {
@@ -11,66 +11,78 @@ import { sseEvents } from "../lib/sse.js"

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

-it.effect("normalizes flat errors in shared SSE and WebSocket decoding", () =>
+it.effect("decodes error frames verbatim 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]) {
-      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,
+      for (const frame of [
+        { type: "error", sequence_number: 4, code: "server_shutting_down", message: "Shutting down", param: null },
        { 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(unchanged))).toEqual(unchanged)
+        expect(yield* decode(JSON.stringify(frame))).toEqual(frame)
      }
    }
  }),
 )

-it.effect("continues to normalize untyped xAI WebSocket errors", () =>
+it.effect("reads bare WebSocket error envelopes as error events", () =>
  Effect.gen(function* () {
    const message = "gRPC error: Response with id=resp_missing not found"
-    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,
-      })
+    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()
    }
  }),
 )

-it.effect("normalizes string errors in shared SSE and WebSocket decoding", () =>
+it.effect("extracts error details from every shape and falls back to the raw frame", () =>
  Effect.gen(function* () {
-    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" } },
-      })
+    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 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,6 +19,13 @@ export function mountBrowserPane() {
      session: "Alpha",
      mounted: true,
      visible: true,
+      url: undefined as string | undefined,
+      loading: false,
+      generation: 0,
+      delayNavigation: false,
+      pendingURL: undefined as string | undefined,
+      loadErrors: {} as Record<string, string | undefined>,
+      error: undefined as string | undefined,
      layouts: {} as Record<string, BrowserPaneLayout | undefined>,
    })
    const tabs = ["Alpha", "Beta"].map((name) => ({
@@ -47,13 +54,33 @@ export function mountBrowserPane() {
      opened: () => !!registrations.get(store.session),
      state: () => ({ tabs: tabs.filter((tab) => tab.title === store.session), focusedTabID: null }),
      tabs: () => tabs.filter((tab) => tab.title === store.session),
-      active: () => tabs.find((tab) => tab.title === store.session) ?? tabs[0],
+      active: () => {
+        const tab = tabs.find((tab) => tab.title === store.session) ?? tabs[0]
+        return {
+          ...tab,
+          url: store.url ?? tab.url,
+          loading: store.loading,
+          generation: store.generation,
+          loadError: store.loadErrors[store.session],
+        }
+      },
      registration: () => registrations.get(store.session),
-      error: () => undefined,
+      error: () => store.error ?? (store.loadErrors[store.session] ? "Request failed" : undefined),
      suspended: () => false,
      close: () => undefined,
      open: () => undefined,
-      command: () => undefined,
+      command: (command) => {
+        setStore("error", undefined)
+        if (command.type === "navigate" || command.type === "reload") setStore("loadErrors", store.session, undefined)
+        if (command.type === "navigate") {
+          if (store.delayNavigation) {
+            setStore("pendingURL", command.url)
+            return
+          }
+          setStore({ url: command.url, loading: false, generation: store.generation + 1 })
+        }
+        if (command.type === "stop") setStore("loading", false)
+      },
    }
    return (
      <>
@@ -64,6 +91,32 @@ export function mountBrowserPane() {
            {(name) => <button onClick={() => setStore({ session: name, mounted: name !== "Empty" })}>{name}</button>}
          </For>
          <button onClick={() => setStore("mounted", false)}>Unmount pane</button>
+          <button onClick={() => setStore({ url: "about:blank", loading: false })}>Blank page</button>
+          <button onClick={() => setStore({ url: "about:blank", loading: true })}>Loading page</button>
+          <button
+            onClick={() =>
+              setStore({ loading: true, generation: store.generation + 1, loadErrors: { [store.session]: undefined } })
+            }
+          >
+            Load current page
+          </button>
+          <button onClick={() => setStore("loadErrors", store.session, "ERR_CONNECTION_REFUSED")}>Failed page</button>
+          <button onClick={() => setStore("delayNavigation", true)}>Delay navigation</button>
+          <button onClick={() => setStore({ error: "ERR_BLOCKED_BY_CLIENT", pendingURL: undefined })}>
+            Block navigation
+          </button>
+          <button
+            onClick={() =>
+              setStore({
+                url: store.pendingURL,
+                pendingURL: undefined,
+                loading: false,
+                generation: store.generation + 1,
+              })
+            }
+          >
+            Complete navigation
+          </button>
          <button onClick={() => setStore("visible", (visible) => !visible)}>Toggle Review tab</button>
        </nav>
        <div style={{ width: "640px", height: "360px", border: "1px solid #555" }}>
@@ -57,3 +57,153 @@ story("hides the native view immediately while the pane stays mounted", async ({
  await toggle.click()
  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
 })
+
+story("shows the empty state over a blank native page and restores navigation", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Blank page", exact: true }).click()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await expect(root.getByText('Or prompt "Open in the app browser"', { exact: true })).toBeVisible()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeDisabled()
+
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://example.com/")
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeEnabled()
+})
+
+story("keeps Stop available and hides the empty state while a blank page loads", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Loading page", exact: true }).click()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+  await root.getByRole("button", { name: "Stop", exact: true }).click()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+})
+
+story("keeps the submitted URL visible until the browser reports navigation", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Blank page", exact: true }).click()
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://example.com/")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(address).toHaveValue("https://example.com/")
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+
+  await root.getByRole("button", { name: "Complete navigation", exact: true }).click()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(address).toHaveValue("https://example.com/")
+
+  await address.fill("https://unsubmitted.example/")
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  await expect(address).toHaveValue("https://example.com/")
+})
+
+story("restores the current URL when a submitted navigation is blocked", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://blocked.example/")
+  await address.press("Enter")
+  await expect(address).toHaveValue("https://blocked.example/")
+  await root.getByRole("button", { name: "Block navigation", exact: true }).click()
+  await expect(root.getByText("ERR_BLOCKED_BY_CLIENT", { exact: true })).toBeVisible()
+  await expect(address).toHaveValue("https://alpha.example/")
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+})
+
+story("shows a themed failure state for only the failed tab and allows retry", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Failed page", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeVisible()
+  await expect(root.getByText("Check the URL and your connection, then try again.", { exact: true })).toBeVisible()
+  await expect(root.getByText("Request failed", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+  await expect(root.getByRole("textbox", { name: "Browser address", exact: true })).toHaveValue(
+    "https://alpha.example/",
+  )
+
+  await root.getByRole("button", { name: "Beta", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Beta")).toHaveAttribute("data-visible", "true")
+  await root.getByRole("button", { name: "Alpha", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeVisible()
+
+  await root.getByRole("button", { name: "Reload", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+})
+
+story("returns a failed tab to the empty state when an empty URL is submitted", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Failed page", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeVisible()
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(address).toHaveValue("")
+  await root.getByRole("button", { name: "Load current page", exact: true }).click()
+  await expect(root.getByRole("button", { name: "Stop", exact: true })).toBeEnabled()
+  await root.getByRole("button", { name: "Complete navigation", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeHidden()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeDisabled()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+})
+
+story("selects the full URL when the address field gains focus", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.click()
+  await expect(address).toHaveJSProperty("selectionStart", 0)
+  await expect(address).toHaveJSProperty("selectionEnd", "https://alpha.example/".length)
+  await address.pressSequentially("https://example.com/")
+  await expect(address).toHaveValue("https://example.com/")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await address.focus()
+  await expect(address).toHaveJSProperty("selectionStart", 0)
+  await expect(address).toHaveJSProperty("selectionEnd", "https://example.com/".length)
+  await address.press("ArrowRight")
+  await address.click()
+  await expect(address).toHaveJSProperty("selectionStart", 0)
+  await expect(address).toHaveJSProperty("selectionEnd", "https://example.com/".length)
+})
+
+story("keeps the current page visible while a submitted URL loads", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://example.com/")
+  await address.press("Enter")
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(address).toHaveValue("https://example.com/")
+
+  await root.getByRole("button", { name: "Load current page", exact: true }).click()
+  await expect(root.getByRole("button", { name: "Stop", exact: true })).toBeEnabled()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await root.getByRole("button", { name: "Complete navigation", exact: true }).click()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(address).toHaveValue("https://example.com/")
+})
+
+story("keeps the current page and restores its URL when an empty address is submitted", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(address).toHaveValue("https://alpha.example/")
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeEnabled()
+})
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/app",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "description": "",
  "type": "module",
  "exports": {
@@ -65,14 +65,14 @@
  }

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

      &:dir(rtl) {
-        --session-summary-translate: max(0px, calc(820px - 50cqi));
+        --session-summary-translate: 160px;
      }
    }
  }
@@ -906,6 +906,10 @@ export const dict = {
  "session.browser.replaced": "Browser control moved to another desktop window.",
  "session.browser.suspended": "Browser suspended. Interact with this session to reconnect.",
  "session.browser.address.placeholder": "Enter URL",
+  "session.browser.empty.title": "Enter URL",
+  "session.browser.empty.description": 'Or prompt "Open in the app browser"',
+  "session.browser.failed.title": "URL can't be reached",
+  "session.browser.failed.description": "Check the URL and your connection, then try again.",

  "titlebar.update": "Update",
  "titlebar.tabs": "Tabs",
@@ -20,13 +20,18 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
  const command = useCommand()
  const state = props.browser.active
  const address = () => (state()?.url === "about:blank" ? "" : (state()?.url ?? ""))
+  const failed = () => !!state()?.loadError
  const registration = props.browser.registration
  const button = { variant: "ghost", size: "large" } as const
  const [store, setStore] = createStore({
    address: "",
    editing: false,
+    submitted: false,
+    // A submitted navigation the browser has not reported yet; keeps the empty state hidden meanwhile.
+    navigating: false,
    visible: typeof document === "undefined" || document.visibilityState === "visible",
  })
+  const empty = () => !address() && !state()?.loading && !store.navigating
  let surface: HTMLDivElement | undefined
  let addressDisplay: HTMLDivElement | undefined
  let frame: number | undefined
@@ -43,7 +48,7 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
      title: language.t("command.browser.reload"),
      category: language.t("command.category.view"),
      keybind: "f5",
-      disabled: !props.visible || !state(),
+      disabled: !props.visible || !address(),
      onSelect: () => {
        const tab = state()
        if (tab) props.browser.command({ type: "reload", tabID: tab.id })
@@ -71,7 +76,9 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
    const top = Math.round(rect.top * zoom)
    const right = Math.round(rect.right * zoom)
    const bottom = Math.round(rect.bottom * zoom)
-    const visible = props.visible && store.visible && !dialog.active && !covered(rect)
+    // The desktop page hides blank and loading documents itself; only hide here
+    // while the pane shows its own empty or failed state over the surface.
+    const visible = props.visible && store.visible && !empty() && !failed() && !dialog.active && !covered(rect)
    // The cutout exposes the app backdrop outside the rounded Review card,
    // not the browser surface inside it.
    const color = getComputedStyle(
@@ -107,7 +114,25 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
    if (frame === undefined) frame = requestAnimationFrame(tick)
  }

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

  return (
    <aside id="browser-panel" class="relative size-full min-w-0 overflow-hidden bg-v2-background-bg-base flex flex-col">
-      <div class="h-10 shrink-0 flex items-center gap-1 px-2 border-b border-v2-border-border-muted">
+      <div class="h-10 shrink-0 flex items-center gap-1 px-3 border-b border-v2-border-border-muted">
        <For each={["back", "forward"] as const}>
          {(direction) => (
            <Tooltip placement="top" value={language.t(direction === "back" ? "common.goBack" : "common.goForward")}>
@@ -193,7 +220,7 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
        >
          <IconButton
            {...button}
-            disabled={!state()}
+            disabled={!state()?.loading && !address()}
            aria-label={language.t(state()?.loading ? "prompt.action.stop" : "error.page.action.reload")}
            onClick={() => {
              const tab = state()
@@ -212,8 +239,13 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
          onSubmit={(event) => {
            event.preventDefault()
            const tab = state()
-            if (tab && store.address.trim())
-              props.browser.command({ type: "navigate", tabID: tab.id, url: store.address })
+            const url = store.address.trim()
+            if (!tab) return
+            if (url || failed()) {
+              setStore({ submitted: true, address: url, navigating: true })
+              props.browser.command({ type: "navigate", tabID: tab.id, url: url || "about:blank" })
+            }
+            event.currentTarget.querySelector("input")?.blur()
          }}
        >
          <input
@@ -224,8 +256,14 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
            disabled={!state()}
            placeholder={language.t("session.browser.address.placeholder")}
            aria-label={language.t("session.browser.address")}
-            onFocus={() => setStore("editing", true)}
-            onBlur={() => setStore({ editing: false, address: address() })}
+            onFocus={(event) => {
+              setStore("editing", true)
+              event.currentTarget.select()
+            }}
+            onClick={(event) => event.currentTarget.select()}
+            onBlur={() =>
+              setStore({ editing: false, address: store.submitted ? store.address : address(), submitted: false })
+            }
            onInput={(event) => setStore("address", event.currentTarget.value)}
            onScroll={(event) => {
              if (addressDisplay) addressDisplay.scrollLeft = event.currentTarget.scrollLeft
@@ -243,12 +281,27 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
          </div>
        </form>
      </div>
-      <Show when={props.browser.error()}>
+      <Show when={props.browser.error() && !failed()}>
        <div class="shrink-0 px-3 py-1.5 text-12-regular text-text-danger-base border-b border-v2-border-border-muted">
          {props.browser.error()}
        </div>
      </Show>
      <div ref={surface} class="min-h-0 flex-1 bg-v2-background-bg-base flex items-center justify-center">
+        <Show when={(empty() || failed()) && !props.browser.suspended()}>
+          {/* Add the 40px toolbar to the file empty state's 160px bottom padding to align their centers. */}
+          <div
+            dir="auto"
+            class="flex size-full flex-col items-center justify-center gap-2 p-6 pb-[200px] text-center text-text-weak"
+          >
+            <Icon name="globe" size="large" class="mb-2 shrink-0" />
+            <div class="text-[13px] font-medium leading-[var(--line-height-compact)] text-text-strong">
+              {language.t(failed() ? "session.browser.failed.title" : "session.browser.empty.title")}
+            </div>
+            <div class="text-13-regular leading-[var(--line-height-base)]">
+              {language.t(failed() ? "session.browser.failed.description" : "session.browser.empty.description")}
+            </div>
+          </div>
+        </Show>
        <Show when={props.browser.suspended()}>
          <p class="px-6 text-center text-13-regular text-v2-text-text-subtle" role="status">
            {language.t("session.browser.suspended")}
@@ -1,6 +1,8 @@
 import { children, createMemo, Show } from "solid-js"
 import type { JSX } from "solid-js"
 import { useSortable } from "@dnd-kit/solid/sortable"
+import { Icon } from "@opencode/ui/icon"
+import { IconButton } from "@opencode/ui/icon-button"
 import { Keybind } from "@opencode/ui/keybind"
 import { Tooltip } from "@opencode/ui/tooltip"
 import { Tabs } from "@opencode/ui/tabs"
@@ -69,9 +71,19 @@ export function SortableTab(props: {
              placement="bottom"
              gutter={10}
            >
-              <Tabs.CloseButton
-                class="h-5 w-5"
-                onClick={() => props.onTabClose(props.tab)}
+              <IconButton
+                size="small"
+                variant="ghost-muted"
+                onPointerDown={(event) => {
+                  event.preventDefault()
+                  event.stopPropagation()
+                }}
+                onClick={(event) => {
+                  event.preventDefault()
+                  event.stopPropagation()
+                  props.onTabClose(props.tab)
+                }}
+                icon={<Icon name="xmark-small" />}
                aria-label={language.t("common.closeTab")}
              />
            </Tooltip>
@@ -9,7 +9,8 @@
  justify-content: center;
 }

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

+[data-titlebar-tab-action]:is(:hover, :focus-visible) {
+  --tab-overlay: var(--v2-overlay-simple-overlay-hover);
+}
+
+[data-titlebar-tab-action]:is(:active, [data-state="pressed"]) {
+  --tab-overlay: var(--v2-overlay-simple-overlay-pressed);
+}
+
 [data-titlebar-tab]:is(:hover, [data-state="pressed"]) [data-slot="tab-close"] {
  background: linear-gradient(var(--tab-overlay), var(--tab-overlay)), var(--tab-base);
 }
@@ -351,9 +351,10 @@ export function Titlebar(props: {
              >
                <button
                  type="button"
+                  data-titlebar-tab-action
                  data-action="vertical-tabs-home"
                  data-state={layout.route().type === "home" ? "pressed" : undefined}
-                  class="group mb-1 flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base data-[state=pressed]:bg-v2-background-bg-layer-02 data-[state=pressed]:text-v2-text-text-base"
+                  class="group mb-1 flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:text-v2-text-text-base data-[state=pressed]:text-v2-text-text-base"
                  onClick={toggleHome}
                  aria-label={language.t("home.title")}
                  aria-pressed={layout.route().type === "home"}
@@ -650,8 +651,9 @@ export function Titlebar(props: {
                            {homeButton(true)}
                            <button
                              type="button"
+                              data-titlebar-tab-action
                              data-action="vertical-tabs-new-session"
-                              class="group flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base"
+                              class="group flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:text-v2-text-text-base"
                              onClick={openNewTab}
                              aria-label={language.t("command.session.new")}
                            >
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/cli",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "type": "module",
  "license": "MIT",
  "bin": {
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/client",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "type": "module",
  "license": "MIT",
  "repository": {
@@ -241,7 +241,6 @@ export type SessionSwitchModelOperation<E = never> = (
 export type SessionUpdateInput = {
  readonly sessionID: Session.ID
  readonly title?: string | undefined
-  readonly metadata?: Session.Metadata | undefined
  readonly permissions?: Permission.Ruleset | undefined
 }
 export type SessionUpdateOutput = void
@@ -517,20 +516,6 @@ export type SessionLogOutput =
            | undefined
          readonly data: { readonly sessionID: Session.ID; readonly title: string }
        }
-      | {
-          readonly id: Event.ID
-          readonly created: number
-          readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.metadata.updated"
-          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
-          readonly location?:
-            | {
-                readonly directory: AbsolutePath
-                readonly workspaceID?: (string & Brand.Brand<"Workspace.ID">) | undefined
-              }
-            | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly metadata: Session.Metadata }
-        }
      | {
          readonly id: Event.ID
          readonly created: number
@@ -453,7 +453,7 @@ const EndpointSessionUpdate = (raw: RawClient["server.session"]) => (input: Sess
  preserveEffect<SessionUpdateOutput>()(
    raw["session.update"]({
      params: { sessionID: input["sessionID"] },
-      payload: { title: input["title"], metadata: input["metadata"], permissions: input["permissions"] },
+      payload: { title: input["title"], permissions: input["permissions"] },
    }).pipe(Effect.mapError(mapClientError)),
  )

@@ -662,7 +662,7 @@ export function make(options: ClientOptions) {
          {
            method: "PATCH",
            path: `/api/session/${encodeURIComponent(input.sessionID)}`,
-            body: { title: input["title"], metadata: input["metadata"], permissions: input["permissions"] },
+            body: { title: input["title"], permissions: input["permissions"] },
            successStatus: 204,
            declaredStatuses: [400, 401, 404],
            empty: true,
@@ -1221,16 +1221,6 @@ export type SessionMoved = {

 export type SessionInboxMovePayload1 = { location: LocationRef; projectID: string; subpath?: string }

-export type SessionMetadataUpdated = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.metadata.updated"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: { sessionID: string; metadata: SessionMetadata }
-}
-
 export type SessionShellStarted = {
  id: string
  created: number
@@ -2318,7 +2308,6 @@ export type SessionEventDurable =
  | SessionModelSelected
  | SessionMoved
  | SessionRenamed
-  | SessionMetadataUpdated
  | SessionPermissions
  | SessionViewed
  | SessionDeleted
@@ -2381,7 +2370,6 @@ export type V2Event =
  | SessionModelSelected
  | SessionMoved
  | SessionRenamed
-  | SessionMetadataUpdated
  | SessionPermissions
  | SessionViewed
  | SessionUsageUpdated
@@ -3958,21 +3946,12 @@ export type SessionUpdateInput = {
  readonly sessionID: { readonly sessionID: string }["sessionID"]
  readonly title?: {
    readonly title?: string | undefined
-    readonly metadata?: { readonly [x: string]: JsonValue } | undefined
    readonly permissions?:
      | ReadonlyArray<{ readonly action: string; readonly resource: string; readonly effect: "allow" | "deny" | "ask" }>
      | undefined
  }["title"]
-  readonly metadata?: {
-    readonly title?: string | undefined
-    readonly metadata?: { readonly [x: string]: JsonValue } | undefined
-    readonly permissions?:
-      | ReadonlyArray<{ readonly action: string; readonly resource: string; readonly effect: "allow" | "deny" | "ask" }>
-      | undefined
-  }["metadata"]
  readonly permissions?: {
    readonly title?: string | undefined
-    readonly metadata?: { readonly [x: string]: JsonValue } | undefined
    readonly permissions?:
      | ReadonlyArray<{ readonly action: string; readonly resource: string; readonly effect: "allow" | "deny" | "ask" }>
      | undefined
@@ -53,7 +53,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] `NaN` and `Infinity` globals.
 - [ ] BigInt literals and in-interpreter BigInt arithmetic; BigInt remains invalid at JSON-like host boundaries.
 - [ ] Arbitrary Symbol primitive values and symbol-keyed properties. The confined `Symbol.iterator` and
-      `Symbol.asyncIterator` keys are available only for custom iterator protocols.
+      `Symbol.asyncIterator` keys are available only for the iterator protocols.
 - [ ] Tagged-template calls.
 - [ ] Getter and setter definitions in object literals.

@@ -92,8 +92,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] `if`/`else` and conditional expressions.
 - [x] `switch`, including default clauses and fallthrough.
 - [x] `for`, `while`, and `do...while`.
- [x] `for...of` over arrays, strings, Maps, Sets, URLSearchParams, Headers, custom synchronous iterators, and
-      confined synchronous generators. Abrupt completion invokes the iterator's optional `return()`.
+- [x] `for...of` over arrays, strings, Maps, Sets, URLSearchParams, Headers, Uint8Arrays, built-in iterators, custom
+      synchronous iterators, and confined synchronous generators. Abrupt completion invokes the iterator's optional `return()`.
 - [x] `for...in` over own keys of plain objects, arrays, strings, and tool references; other values iterate nothing.
 - [x] Unlabeled `break` and `continue`.
 - [x] `try`, `catch`, optional catch bindings, and `finally`.
@@ -180,7 +180,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      on any other value throws a catchable `TypeError` naming the callee: other built-in functions such as `Number`
      say `new` is unsupported and point at the plain call, user-defined functions report the constructor gap below,
      and non-callable values are not constructors. Error constructors take the ES2022 options object, so
-      `new Error(message, { cause })` installs a non-enumerable `cause` when the option is present.
+      `new Error(message, { cause })` installs a non-enumerable `cause` when the option is present. `Error.isError`
+      is true for every Error value.
 - [x] Arithmetic operators: `+`, `-`, `*`, `/`, `%`, and `**`.
 - [x] Equality and ordering: `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, and `>=`.
 - [x] Bitwise operators: `&`, `|`, `^`, `~`, `<<`, `>>`, and `>>>`.
@@ -270,8 +271,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] `Object.is` for supported data values.
 - [x] `Object.groupBy` over finite collections and custom synchronous iterators/generators, with string-key coercion
      and plain-object results.
- [x] `Object.prototype` methods on values: `toString` (`"[object Array]"`), `toLocaleString`, `valueOf`,
-      `hasOwnProperty`, `isPrototypeOf`, and `propertyIsEnumerable`.
+- [x] `Object.prototype` methods on values: `toString` (`"[object Array]"`), `toLocaleString` (calls the value's
+      `toString`, as in JS), `valueOf`, `hasOwnProperty`, `isPrototypeOf`, and `propertyIsEnumerable`.

 ## Arrays

@@ -285,9 +286,13 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      `lastIndexOf`.
 - [x] Aggregation: `reduce` and `reduceRight`.
 - [x] Ordering: `sort`, `toSorted`, `reverse`, and `toReversed`.
- [x] Access/copying: `at`, `slice`, `concat`, `flat`, `with`, and `join`.
+- [x] Access/copying: `at`, `slice`, `concat`, `flat`, `with`, `join`, and `toLocaleString` (each element's
+      `toLocaleString`, holes and nullish elements as empty strings).
 - [x] Mutation: `push`, `pop`, `shift`, `unshift`, `splice`, `fill`, and `copyWithin`.
- [x] Materialized iteration helpers: `keys`, `values`, and `entries` return arrays rather than iterators.
+- [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] `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`.
@@ -302,11 +307,11 @@ 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

- [x] Case/normalization: `toLowerCase`, `toUpperCase`, `normalize`.
+- [x] Case/normalization: `toLowerCase`, `toUpperCase`, `normalize`, and the `toLocaleLowerCase`/`toLocaleUpperCase`
+      aliases, which ignore their locale argument and apply the default Unicode casing.
 - [x] Trimming: `trim`, `trimStart`, and `trimEnd`, plus the Annex B `trimLeft` and `trimRight` aliases.
 - [x] Searching/tests: `includes`, `startsWith`, `endsWith`, `indexOf`, `lastIndexOf`, and `search`.
 - [x] Slicing/access: `slice`, `substring`, Annex B `substr`, `at`, `charAt`, `charCodeAt`, and `codePointAt`.
@@ -314,7 +319,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, and `for...of` by Unicode code point.
+- [x] `toString`, `length`, numeric indexing, spread, `for...of`, and `[Symbol.iterator]` 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
@@ -330,7 +335,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Coercion functions: `Number`, `parseInt`, and `parseFloat`.
 - [x] Number predicates/parsers: `Number.isInteger`, `Number.isFinite`, `Number.isNaN`, `Number.isSafeInteger`,
      `Number.parseInt`, and `Number.parseFloat`.
- [x] Number formatting: `toFixed`, `toPrecision`, `toExponential`, `toString`, and `valueOf`.
+- [x] Number formatting: `toFixed`, `toPrecision`, `toExponential`, `toString`, `valueOf`, and `toLocaleString`, which
+      always formats as `en-US` (`"1,234.5"`) so output does not depend on the host.
 - [x] Number constants: `MAX_SAFE_INTEGER`, `MIN_SAFE_INTEGER`, `MAX_VALUE`, `MIN_VALUE`, `EPSILON`, `NaN`,
      `POSITIVE_INFINITY`, and `NEGATIVE_INFINITY`.
 - [x] Math constants: `PI`, `E`, `LN2`, `LN10`, `LOG2E`, `LOG10E`, `SQRT2`, and `SQRT1_2`.
@@ -377,6 +383,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      `TimeClip` behavior.
 - [x] `Date.prototype.toUTCString` and its `toGMTString` alias.
 - [x] `toDateString` and `toTimeString` in the host's local timezone.
+- [x] `toLocaleString`, `toLocaleDateString`, and `toLocaleTimeString` always format as `en-US` in UTC
+      (`"1/1/1970, 12:00:00 AM"`) so output does not depend on the host.
 - [x] Native one-argument Date coercion for supported values, including booleans, null, arrays, and plain objects.
 - [ ] Date setters and multi-argument construction coerce object arguments through `valueOf`/`toString` and surface
      their throws.
@@ -402,10 +410,11 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262

 - [x] Static `Map.groupBy` over finite collections and custom synchronous iterators/generators, preserving key identity.
 - [x] `new Map()` from synchronous iterables of entries.
- [x] Map `get`, `set`, `has`, `delete`, `clear`, `size`, and `forEach`.
+- [x] Map `get`, `set`, `has`, `delete`, `clear`, `size`, `forEach`, `getOrInsert`, and `getOrInsertComputed`.
 - [x] `new Set()` from synchronous iterables.
 - [x] Set `add`, `has`, `delete`, `clear`, `size`, and `forEach`.
- [x] Materialized `keys`, `values`, and `entries` arrays for Map and Set.
+- [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] 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`,
@@ -421,7 +430,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`, `toString`, and `size`.
+      `entries`, `[Symbol.iterator]`, `toString`, and `size`.
 - [x] URL values serialize to their href; URLSearchParams serialize to `{}`.

 ## Uint8Array
@@ -434,7 +443,8 @@ 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 materialized `keys`, `values`, and `entries` arrays.
+      `includes`, `join`, `toString`, `toBase64`, `toHex`, and live `keys`, `values`, `entries`, and `[Symbol.iterator]`
+      iterators.
 - [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) [...]`.
@@ -450,8 +460,8 @@ with a hint to encode as text first (`TextDecoder`, `toBase64`, `toHex`).
      `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`, and `entries`;
-      iteration is live and sorted by name, with `set-cookie` values kept apart.
+- [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.
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/codemode",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "description": "Effect-native confined code execution over schema-described tools",
  "type": "module",
  "license": "MIT",
@@ -1,6 +1,7 @@
 import { Effect, Exit } from "effect"
 import { coerceToNumber, coerceToString } from "../stdlib/value.js"
 import type { Interpreter } from "./interpreter.js"
+import { primitivePrototype } from "./intrinsics.js"
 import { typeError } from "./model.js"
 import { Callable, get, Native, DateObj, Obj } from "./objects.js"
 import { typeofValue } from "./references.js"
@@ -43,6 +44,13 @@ export const toPrimitive = <R>(
  })
 }

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

@@ -168,6 +168,7 @@ export const errorGlobal = <R>(type: ErrorType, ctx: Interpreter<R>) => {
    methods(builtins, prototype, [
      ["toString", 0, (thisValue) => errorToString(receiver(Obj, thisValue, "Error.prototype.toString"))],
    ])
+    methods(builtins, ctor, [["isError", 1, (_, args) => args[0] instanceof ErrorObj]])
  }
  return ctor
 }
@@ -20,6 +20,7 @@ import {
  DateObj,
  ErrorObj,
  GeneratorObj,
+  IteratorObj,
  MapObj,
  Obj,
  PromiseObj,
@@ -61,6 +62,7 @@ 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.`)
@@ -12,6 +12,7 @@ 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"
@@ -101,5 +102,6 @@ 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)
 }
@@ -62,7 +62,7 @@ import {
 } from "./model.js"
 import { checkStringLength } from "./limits.js"
 import { locate, materialize } from "./errors.js"
-import type { Builtins } from "./intrinsics.js"
+import { type Builtins, primitivePrototype } from "./intrinsics.js"
 import { globals } from "./globals.js"
 import {
  assign,
@@ -79,6 +79,7 @@ import {
  DateObj,
  Fn,
  GeneratorObj,
+  IteratorObj,
  MapObj,
  Obj,
  PromiseObj,
@@ -650,8 +651,8 @@ class Frame<R> {
      if (declared?.lexical) self.predeclarePattern(declared.pattern, declared.mutable, left)
      const right = yield* self.evaluateExpression(node.right)

-      const iterator = yield* self.customIterator(right, node, awaiting)
-      const cursor = iterator === undefined ? yield* self.iterate(right, node) : undefined
+      const cursor = self.hostCursor(right)
+      const iterator = cursor === undefined ? yield* self.customIterator(right, node, awaiting) : undefined
      if (iterator === undefined && cursor === undefined) {
        throw invalidData(
          `${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, URLSearchParams, or Headers, or custom iterator value.`,
@@ -746,6 +747,20 @@ 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]()
@@ -761,29 +776,21 @@ class Frame<R> {
                  ? value.headers.entries()
                  : 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,
-      })
+                    : 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,
    }
-    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) {
@@ -2064,16 +2071,14 @@ class Frame<R> {

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

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

      if (objectValue === null || objectValue === undefined) {
        throw typeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode)
@@ -52,6 +52,14 @@ export const createErrorValue = (prototype: Obj, message: string | undefined): E
  return value
 }

+/** The prototype a primitive reads its methods from without being boxed; none for null, undefined, and symbols. */
+export const primitivePrototype = (builtins: Builtins, value: unknown): Obj | undefined => {
+  if (typeof value === "string") return builtins.String
+  if (typeof value === "number") return builtins.Number
+  if (typeof value === "boolean") return builtins.Boolean
+  return undefined
+}
+
 export const createBuiltins = (): Builtins => {
  const object = new Obj(null)
  // Function.prototype is itself callable and returns undefined.
@@ -122,6 +122,16 @@ 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,
@@ -9,6 +9,7 @@ import {
  Bytes,
  DateObj,
  GeneratorObj,
+  IteratorObj,
  MapObj,
  Obj,
  PromiseObj,
@@ -23,6 +24,7 @@ import {
 export const isRuntimeReference = (value: unknown): boolean =>
  value instanceof Callable ||
  value instanceof GeneratorObj ||
+  value instanceof IteratorObj ||
  value instanceof ToolReference ||
  value instanceof PromiseObj ||
  isWrapper(value)
@@ -89,6 +91,7 @@ export const describeValue = (value: unknown): string => {
  if (value instanceof HeadersObj) return "a Headers"
  if (value instanceof Bytes) return "a Uint8Array"
  if (value instanceof GeneratorObj) return "a generator"
+  if (value instanceof IteratorObj) return "an iterator"
  if (isRuntimeReference(value)) return "a function"
  if (typeof value === "object") return "a data object"
  return `a ${typeof value}`
@@ -1,10 +1,10 @@
 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, rangeError, typeError } from "../interpreter/model.js"
-import { get, Arr, GeneratorObj, Obj } from "../interpreter/objects.js"
+import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js"
+import { define, get, hidden, Arr, GeneratorObj, IteratorObj, Obj } from "../interpreter/objects.js"
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js"
-import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js"
+import { applyCollectionCallback, invoke, preserveConsumerError } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
 import { compareText } from "../tool-runtime.js"
 import { coerceToNumber, coerceToString } from "./value.js"
@@ -340,13 +340,31 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
        return target
      },
    ],
-    ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").items.keys()))],
-    ["values", 0, (thisValue) => wrap([...self(thisValue, "values").items])],
+    [
+      "toLocaleString",
+      0,
+      (thisValue) =>
+        Effect.map(
+          Effect.forEach(self(thisValue, "toLocaleString").items, (item) =>
+            item === null || item === undefined
+              ? Effect.succeed("")
+              : Effect.map(invoke(ctx, item, "toLocaleString", "Array.prototype.toLocaleString"), coerceToString),
+          ),
+          (parts) => parts.join(","),
+        ),
+    ],
+    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").items.keys())],
+    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").items.values())],
    [
      "entries",
      0,
      (thisValue) =>
-        wrap(Array.from(self(thisValue, "entries").items.entries(), ([index, item]) => wrap([index, item]))),
+        new IteratorObj(
+          builtins.Iterator,
+          self(thisValue, "entries")
+            .items.entries()
+            .map(([index, item]) => wrap([index, item])),
+        ),
    ],
    iterate("map", 1, (target, receiver, apply) =>
      Effect.gen(function* () {
@@ -490,5 +508,6 @@ 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 { rangeError, syntaxError, typeError } from "../interpreter/model.js"
-import { defineAccessor, get, Arr, Bytes, Obj } from "../interpreter/objects.js"
+import { IteratorSymbol, rangeError, syntaxError, typeError } from "../interpreter/model.js"
+import { define, defineAccessor, get, hidden, Arr, Bytes, IteratorObj, Obj } from "../interpreter/objects.js"
 import { describeValue } from "../interpreter/references.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
 import { coerceToNumber, coerceToString } from "./value.js"
@@ -173,15 +173,21 @@ 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) => wrapAll(Array.from(self(thisValue, "keys").bytes.keys()))],
-    ["values", 0, (thisValue) => wrapAll(Array.from(self(thisValue, "values").bytes.values()))],
+    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").bytes.keys())],
+    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").bytes.values())],
    [
      "entries",
      0,
      (thisValue) =>
-        wrapAll(Array.from(self(thisValue, "entries").bytes.entries(), ([index, byte]) => wrapAll([index, byte]))),
+        new IteratorObj(
+          builtins.Iterator,
+          self(thisValue, "entries")
+            .bytes.entries()
+            .map(([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, typeError } from "../interpreter/model.js"
+import { invalidData, IteratorSymbol, typeError } from "../interpreter/model.js"
 import {
  define,
  defineAccessor,
@@ -9,6 +9,7 @@ import {
  hidden,
  isWrapper,
  Arr,
+  IteratorObj,
  MapObj,
  Obj,
  PromiseObj,
@@ -144,6 +145,29 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {
        return target
      },
    ],
+    [
+      "getOrInsert",
+      2,
+      (thisValue, args) => {
+        const target = self(thisValue, "getOrInsert").map
+        if (!target.has(args[0])) target.set(args[0], args[1])
+        return target.get(args[0])
+      },
+    ],
+    [
+      "getOrInsertComputed",
+      2,
+      (thisValue, args) => {
+        const target = self(thisValue, "getOrInsertComputed").map
+        const apply = applyCollectionCallback(ctx, args[1], "Map.getOrInsertComputed")
+        if (target.has(args[0])) return target.get(args[0])
+        // The callback sees the stored key (-0 is +0) and its result wins over anything it inserted itself.
+        return Effect.map(apply([args[0] === 0 ? 0 : args[0]]), (value) => {
+          target.set(args[0], value)
+          return value
+        })
+      },
+    ],
    ["delete", 1, (thisValue, args) => self(thisValue, "delete").map.delete(args[0])],
    [
      "clear",
@@ -153,12 +177,18 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {
        return undefined
      },
    ],
-    ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").map.keys()))],
-    ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").map.values()))],
+    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").map.keys())],
+    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").map.values())],
    [
      "entries",
      0,
-      (thisValue) => wrap(Array.from(self(thisValue, "entries").map.entries(), ([key, item]) => wrap([key, item]))),
+      (thisValue) =>
+        new IteratorObj(
+          builtins.Iterator,
+          self(thisValue, "entries")
+            .map.entries()
+            .map(([key, item]) => wrap([key, item])),
+        ),
    ],
    [
      "forEach",
@@ -173,6 +203,7 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {
      },
    ],
  ])
+  define(proto, IteratorSymbol, get(proto, "entries"), hidden)
  return map
 }

@@ -218,7 +249,8 @@ 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.flatMap(ctx.call(keys, source, []), (result): Effect.Effect<Iterable<unknown>> => {
+          if (result instanceof IteratorObj) return Effect.succeed(result.iterator)
          if (result instanceof Arr) return Effect.succeed(result.items)
          throw typeError(`Set.${name} expected 'keys' to return an iterator.`)
        }),
@@ -338,12 +370,18 @@ export const setGlobal = <R>(ctx: Interpreter<R>) => {
        return undefined
      },
    ],
-    ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").set.values()))],
-    ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").set.values()))],
+    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").set.values())],
+    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").set.values())],
    [
      "entries",
      0,
-      (thisValue) => wrap(Array.from(self(thisValue, "entries").set.values(), (item) => wrap([item, item]))),
+      (thisValue) =>
+        new IteratorObj(
+          builtins.Iterator,
+          self(thisValue, "entries")
+            .set.values()
+            .map((item) => wrap([item, item])),
+        ),
    ],
    [
      "forEach",
@@ -365,5 +403,6 @@ export const setGlobal = <R>(ctx: Interpreter<R>) => {
    operation("isSupersetOf"),
    operation("isDisjointFrom"),
  ])
+  define(proto, IteratorSymbol, get(proto, "values"), hidden)
  return set
 }
@@ -105,6 +105,13 @@ export const dateGlobal = <R>(ctx: Interpreter<R>) => {
    ["toTimeString", 0, (thisValue) => new Date(self(thisValue, "toTimeString").time).toTimeString()],
    ["toUTCString", 0, (thisValue) => new Date(self(thisValue, "toUTCString").time).toUTCString()],
    ["toGMTString", 0, (thisValue) => new Date(self(thisValue, "toGMTString").time).toUTCString()],
+    ...(["toLocaleString", "toLocaleDateString", "toLocaleTimeString"] as const).map(
+      (name): Method => [
+        name,
+        0,
+        (thisValue) => new Date(self(thisValue, name).time)[name]("en-US", { timeZone: "UTC" }),
+      ],
+    ),
    ...getters.map((name): Method => [name, 0, (thisValue) => new Date(self(thisValue, name).time)[name]()]),
    ...setters.map(
      ([name, length]): Method => [
@@ -1,7 +1,7 @@
 import { Effect } from "effect"
 import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js"
-import { typeError } from "../interpreter/model.js"
-import { entries, Arr, HeadersObj, Obj } from "../interpreter/objects.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"
@@ -93,13 +93,25 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
        return attempt(() => target.set(arg(args, 0), arg(args, 1)))
      },
    ],
-    ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").headers.keys()))],
-    ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").headers.values()))],
+    // 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) =>
-        wrap(Array.from(self(thisValue, "entries").headers.entries(), ([key, value]) => wrap([key, value]))),
+        new IteratorObj(
+          builtins.Iterator,
+          Iterator.from(self(thisValue, "entries").headers.entries()).map(([key, value]) => wrap([key, value])),
+        ),
    ],
    [
      "forEach",
@@ -115,5 +127,6 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
      },
    ],
  ])
+  define(proto, IteratorSymbol, get(proto, "entries"), hidden)
  return headers
 }
@@ -0,0 +1,19 @@
+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) })
+      },
+    ],
+  ])
+}
@@ -50,6 +50,7 @@ export const numberGlobal = <R>(ctx: Interpreter<R>) => {
  }
  methods(builtins, builtins.Number, [
    ["toFixed", 1, (thisValue, args) => self(thisValue, "toFixed").toFixed(optNum("toFixed", args[0]))],
+    ["toLocaleString", 0, (thisValue) => self(thisValue, "toLocaleString").toLocaleString("en-US")],
    [
      "toExponential",
      1,
@@ -29,7 +29,7 @@ import {
  set,
 } from "../interpreter/objects.js"
 import { containsOpaqueReference, describeValue, rejectCircularInsertion } from "../interpreter/references.js"
-import { preserveConsumerError } from "../interpreter/callback.js"
+import { invoke, preserveConsumerError } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
 import { ToolReference } from "../tool-runtime.js"
 import { groupBy } from "./collections.js"
@@ -196,7 +196,7 @@ export const objectGlobal = <R>(ctx: Interpreter<R>) => {
        true,
    ],
    ["toString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
-    ["toLocaleString", 0, (thisValue) => `[object ${classTag(thisValue)}]`],
+    ["toLocaleString", 0, (thisValue) => invoke(ctx, thisValue, "toString", "Object.prototype.toLocaleString")],
    [
      "valueOf",
      0,
@@ -1,8 +1,8 @@
 import { Effect } from "effect"
-import { constructor, type Method, methods } from "../interpreter/native.js"
+import { constructor, fn, type Method, methods } from "../interpreter/native.js"
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js"
-import { invalidData, rangeError, typeError } from "../interpreter/model.js"
-import { Arr, PromiseObj, RegExpObj, record } from "../interpreter/objects.js"
+import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js"
+import { define, hidden, Arr, IteratorObj, PromiseObj, RegExpObj, record } from "../interpreter/objects.js"
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js"
 import { applyCollectionCallback, isSupportedCallback } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
@@ -150,6 +150,8 @@ export const stringGlobal = <R>(ctx: Interpreter<R>) => {
    simple("valueOf", 0, (value) => value),
    simple("toLowerCase", 0, (value) => value.toLowerCase()),
    simple("toUpperCase", 0, (value) => value.toUpperCase()),
+    simple("toLocaleLowerCase", 0, (value) => value.toLowerCase()),
+    simple("toLocaleUpperCase", 0, (value) => value.toUpperCase()),
    simple("trim", 0, (value) => value.trim()),
    simple("trimStart", 0, (value) => value.trimStart()),
    simple("trimLeft", 0, (value) => value.trimStart()),
@@ -258,5 +260,16 @@ 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,7 +1,19 @@
 import { Effect } from "effect"
 import { constructor, fn, type Method, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js"
-import { PendingThrow, typeError, uriError } from "../interpreter/model.js"
-import { defineAccessor, entries, isWrapper, Arr, Obj, URLObj, URLSearchParamsObj } from "../interpreter/objects.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 { isRuntimeReference } from "../interpreter/references.js"
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
@@ -258,13 +270,18 @@ export const urlSearchParamsGlobal = <R>(ctx: Interpreter<R>) => {
        return undefined
      },
    ],
-    ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").params.keys()))],
-    ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").params.values()))],
+    ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").params.keys())],
+    ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").params.values())],
    [
      "entries",
      0,
      (thisValue) =>
-        wrap(Array.from(self(thisValue, "entries").params.entries(), ([key, value]) => wrap([key, value]))),
+        new IteratorObj(
+          builtins.Iterator,
+          self(thisValue, "entries")
+            .params.entries()
+            .map(([key, value]) => wrap([key, value])),
+        ),
    ],
    ["toString", 0, (thisValue) => self(thisValue, "toString").params.toString()],
    [
@@ -281,5 +298,6 @@ export const urlSearchParamsGlobal = <R>(ctx: Interpreter<R>) => {
      },
    ],
  ])
+  define(proto, IteratorSymbol, get(proto, "entries"), hidden)
  return searchParams
 }
@@ -298,21 +298,18 @@ const cases = [
  },
  {
    path: "test/built-ins/Array/prototype/keys/iteration.js",
-    code: `return ["a", "b", "c"].keys()`,
-    expected: [0, 1, 2],
+    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 }],
  },
  {
    path: "test/built-ins/Array/prototype/values/iteration.js",
-    code: `return ["a", "b", "c"].values()`,
-    expected: ["a", "b", "c"],
+    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 }],
  },
  {
    path: "test/built-ins/Array/prototype/entries/iteration.js",
-    code: `return ["a", "b"].entries()`,
-    expected: [
-      [0, "a"],
-      [1, "b"],
-    ],
+    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 }],
  },
  {
    path: "test/built-ins/Array/isArray/15.4.3.2-0-3.js",
@@ -22,6 +22,16 @@ describe("source syntax", () => {
 })

 describe("error identity", () => {
+  test("Error.isError is true for every Error value and nothing else", async () => {
+    expect(
+      await value(`
+        const caught = (() => { try { null.foo } catch (error) { return error } })()
+        return [Error.isError(new Error("x")), Error.isError(new RangeError("x")), Error.isError(caught),
+          Error.isError({ name: "Error", message: "x" }), Error.isError("Error"), Error.isError(null)]
+      `),
+    ).toEqual([true, true, true, false, false, false])
+  })
+
  test("awaiting the same rejected promise twice yields the same error object", async () => {
    expect(
      await value(`
@@ -220,8 +220,9 @@ describe("values are converted at the boundary, never shared", () => {
    expect(held[1]).toBeInstanceOf(Error)
  })

-  test("functions, promises, and symbols cannot be passed in", async () => {
+  test("functions, promises, iterators, 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 arrays usable with for...of and spread", async () => {
+  test("keys/values/entries return iterators usable with for...of and spread", async () => {
    expect(await value(`return [...["x","y","z"].keys()]`)).toEqual([0, 1, 2])
-    expect(await value(`return ["x","y"].values()`)).toEqual(["x", "y"])
+    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).values()[1] === Infinity,
-          1 / new Set([0, 1, 2]).intersection(setlike).values()[0] === Infinity,
+          1 / [...new Set([1]).union(setlike)][1] === Infinity,
+          1 / [...new Set([0, 1, 2]).intersection(setlike)][0] === Infinity,
          [...new Set([0, 1]).difference(setlike)],
-          1 / new Set([1, 2]).symmetricDifference(setlike).values()[2] === Infinity,
+          1 / [...new Set([1, 2]).symmetricDifference(setlike)][2] === Infinity,
        ]
      `),
    ).toEqual([true, true, [1], true])
@@ -655,9 +655,9 @@ describe("Headers", () => {
          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(),
+          keys: [...headers.keys()],
+          values: [...headers.values()],
+          entries: [...headers.entries()],
        }
      `),
    ).toEqual({
@@ -816,18 +816,28 @@ describe("Map", () => {
    expect((await error(`return new Map(["flat"])`)).message).toMatch(/\[key, value\] pairs/)
  })

-  test("keys/values/entries return arrays", async () => {
+  test("keys/values/entries return live iterators", async () => {
    expect(
      await value(`
      const m = new Map([["a", 1], ["b", 2]])
-      return { keys: m.keys(), values: m.values(), entries: m.entries() }
+      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]()] }
    `),
    ).toEqual({
-      keys: ["a", "b"],
-      values: [1, 2],
+      first: { value: "a", done: false },
+      rest: ["b", "c"],
+      values: [1, 2, 3],
      entries: [
        ["a", 1],
        ["b", 2],
+        ["c", 3],
+      ],
+      same: [
+        ["a", 1],
+        ["b", 2],
+        ["c", 3],
      ],
    })
  })
@@ -888,6 +898,42 @@ describe("Map", () => {
    ).toEqual({ a: 3, b: 1, c: 1 })
  })

+  test("getOrInsert and getOrInsertComputed insert only when the key is missing", async () => {
+    expect(
+      await value(`
+      const groups = new Map()
+      groups.getOrInsert("a", []).push(1)
+      groups.getOrInsert("a", []).push(2)
+      let calls = 0
+      const computed = (key) => { calls++; return key + "!" }
+      const first = groups.getOrInsertComputed("b", computed)
+      const second = groups.getOrInsertComputed("b", computed)
+      const zero = groups.getOrInsertComputed(-0, (key) => 1 / key === Infinity)
+      return [[...groups], first, second, calls, zero]
+    `),
+    ).toEqual([
+      [
+        ["a", [1, 2]],
+        ["b", "b!"],
+        [0, true],
+      ],
+      "b!",
+      "b!",
+      1,
+      true,
+    ])
+    expect(
+      await value(`
+      const m = new Map()
+      const outer = m.getOrInsertComputed("k", () => { m.set("k", "inner"); return "outer" })
+      let thrown
+      try { m.getOrInsertComputed("j", () => { throw new Error("boom") }) } catch (error) { thrown = error.message }
+      return [outer, m.get("k"), thrown, m.has("j")]
+    `),
+    ).toEqual(["outer", "outer", "boom", false])
+    expect((await error(`new Map().getOrInsertComputed("k", 5)`)).message).toContain("expects a function callback")
+  })
+
  test("maps serialize to {} at the boundary, like JSON", async () => {
    expect(await value(`return new Map([["a", 1]])`)).toEqual({})
    expect(await value(`return JSON.stringify(new Map([["a", 1]]))`)).toBe("{}")
@@ -1051,7 +1097,7 @@ describe("Uint8Array", () => {
      console.log(b, new Uint8Array())
      return [String(b), b + "", +new Uint8Array([5]), Number.isNaN(Number(b)), b == "1,2", JSON.stringify(b), b.toLocaleString(), typeof b, b instanceof Uint8Array]
    `),
-    ).toEqual(["1,2", "1,2", 5, true, true, '{"0":1,"1":2}', "[object Uint8Array]", "object", true])
+    ).toEqual(["1,2", "1,2", 5, true, true, '{"0":1,"1":2}', "1,2", "object", true])
    expect((await run(`console.log(new Uint8Array([1, 2]), new Uint8Array())`)).logs).toEqual([
      "Uint8Array(2) [1,2] Uint8Array(0) []",
    ])
@@ -1119,6 +1165,151 @@ 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("toLocaleString", () => {
+  test("numbers and dates format as en-US in UTC; everything else falls back to toString", async () => {
+    expect(
+      await value(`
+      return [
+        (1234567.891).toLocaleString(), new Date(0).toLocaleString(), new Date(0).toLocaleDateString(),
+        new Date(0).toLocaleTimeString(), "a".toLocaleString(), true.toLocaleString(), ({}).toLocaleString(),
+        ({ toString: () => "custom" }).toLocaleString(), new Uint8Array([1, 2]).toLocaleString(),
+      ]
+    `),
+    ).toEqual([
+      "1,234,567.891",
+      "1/1/1970, 12:00:00 AM",
+      "1/1/1970",
+      "12:00:00 AM",
+      "a",
+      "true",
+      "[object Object]",
+      "custom",
+      "1,2",
+    ])
+  })
+
+  test("arrays join each element's toLocaleString, skipping holes and nullish elements", async () => {
+    expect(
+      await value(`
+      let calls = 0
+      const item = { toLocaleString() { calls++; return "o" } }
+      return [[1234.5, "x", null, undefined, item, new Date(0)].toLocaleString(), [, item, , item].toLocaleString(), calls]
+    `),
+    ).toEqual(["1,234.5,x,,,o,1/1/1970, 12:00:00 AM", ",o,,o", 3])
+    expect((await error(`const f = ({}).toLocaleString; f()`)).message).toContain(
+      "Object.prototype.toLocaleString called on null or undefined",
+    )
+  })
+
+  test("toLocaleLowerCase and toLocaleUpperCase ignore the locale argument", async () => {
+    expect(
+      await value(`return ["ABC".toLocaleLowerCase("tr"), "abc".toLocaleUpperCase(), "İ".toLocaleLowerCase()]`),
+    ).toEqual(["abc", "ABC", "i̇"])
+  })
+})
+
 describe("stdlib integration", () => {
  test("constructor follows own keys, shadowing, writes, and new", async () => {
    expect(
@@ -13,8 +13,6 @@ 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
@@ -86,8 +84,6 @@ 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.
@@ -229,7 +225,6 @@ built-ins/Array/prototype/splice/S15.4.4.12_A4_T1.js  # Array.prototype.splice c
 built-ins/Array/prototype/splice/S15.4.4.12_A4_T2.js  # Array.prototype.splice called on incompatible receiver a data object.
 built-ins/Array/prototype/splice/S15.4.4.12_A4_T3.js  # Array.prototype.splice called on incompatible receiver a data object.
 built-ins/Array/prototype/splice/create-ctor-non-object.js  # null value Expected a TypeError to be thrown but no exception was thrown at all
-built-ins/Array/prototype/toLocaleString/S15.4.4.3_A1_T1.js  # #1: var n = 0; var obj = {toLocaleString: function() {n++}}; var arr = [undefined, obj, null, obj, o
 built-ins/Array/prototype/toLocaleString/S15.4.4.3_A3_T1.js  # #1: var n = 0; var obj = {toLocaleString: function() {n++}}; Array.prototype[1] = obj; x = [obj]; x.
 built-ins/Array/prototype/toReversed/holes-not-preserved.js  # Actual [4, undefined, 2, undefined, 0] and expected [4, 3, 2, undefined, 0] should have the same con
 built-ins/Array/prototype/toSorted/holes-not-preserved.js  # Actual [1, 3, 4, undefined, undefined] and expected [1, 2, 3, 4, undefined] should have the same con
@@ -241,9 +236,6 @@ 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
@@ -291,16 +283,13 @@ 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.
@@ -308,8 +297,6 @@ 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
@@ -355,7 +342,6 @@ 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
@@ -406,8 +392,6 @@ 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
@@ -8,8 +8,8 @@
 * 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.
- * Headers cases that need `Symbol.iterator`, iterator objects from `keys()`/`values()`/`entries()` (CodeMode returns
- * arrays), or a custom iterator on a Headers instance are left out.
+ * `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"
@@ -253,33 +253,64 @@ describe("Headers WPT parity (fetch/api/headers)", () => {
        }).sort()
        test(function() {
          var headers = new Headers(headerEntriesDict)
-          assert_array_equals(headers.keys(), sortedHeaderKeys)
+          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)
-          assert_array_equals(headers.values(), sortedHeaderKeys.map((key) => sortedHeaderDict[key]))
+          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)
-          assert_array_equals(headers.entries(), sortedHeaderKeys.map((key) => [key, sortedHeaderDict[key]]))
+          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)
-          assert_array_equals([...headers], sortedHeaderKeys.map((key) => [key, sortedHeaderDict[key]]))
+          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 index = 0
+          var reference = sortedHeaderKeys[Symbol.iterator]()
          headers.forEach(function(value, key, container) {
            assert_equals(headers, container)
-            assert_equals(key, sortedHeaderKeys[index])
-            assert_equals(value, sortedHeaderDict[sortedHeaderKeys[index]])
-            index++
+            const entry = reference.next()
+            assert_false(entry.done)
+            assert_equals(key, entry.value)
+            assert_equals(value, sortedHeaderDict[entry.value])
          })
-          assert_equals(index, sortedHeaderKeys.length)
+          assert_true(reference.next().done)
        }, "Check forEach method")
        test(() => {
          const headers = new Headers({"foo": "2", "baz": "1", "BAR": "0"})
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-app",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/console-core",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-function",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-mail",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "dependencies": {
    "@jsx-email/all": "2.2.3",
    "@jsx-email/cli": "1.4.3",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/console-support",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.10",
+  "version": "2.0.11",
  "name": "@opencode/core",
  "type": "module",
  "license": "MIT",
@@ -57,16 +57,19 @@ 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.tap((data) => Effect.sync(() => (loaded.data = snapshots(data)))),
-          Effect.andThen(ctx.integration.reload()),
-          Effect.andThen(ctx.provider.reload()),
-        ),
-      ),
+      Stream.runForEach(() => modelsDev.get().pipe(Effect.flatMap(apply))),
      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)
  }),
 })

@@ -170,10 +170,6 @@ export interface Interface {
  readonly switchAgent: (input: { sessionID: SessionSchema.ID; agent: Agent.ID }) => Effect.Effect<void, NotFoundError>
  readonly switchModel: (input: { sessionID: SessionSchema.ID; model: Model.Ref }) => Effect.Effect<void, NotFoundError>
  readonly rename: (input: { sessionID: SessionSchema.ID; title: string }) => Effect.Effect<void, NotFoundError>
-  readonly setMetadata: (input: {
-    sessionID: SessionSchema.ID
-    metadata: SessionSchema.Metadata
-  }) => Effect.Effect<void, NotFoundError>
  readonly setPermissions: (input: {
    sessionID: SessionSchema.ID
    permissions: Permission.Ruleset
@@ -421,7 +417,6 @@ const layer = Layer.effect(
      switchAgent: (input) => sessions.forSession(input.sessionID).switchAgent(input),
      switchModel: (input) => sessions.forSession(input.sessionID).switchModel(input),
      rename: (input) => sessions.forSession(input.sessionID).rename(input),
-      setMetadata: (input) => sessions.forSession(input.sessionID).setMetadata(input),
      setPermissions: (input) => sessions.forSession(input.sessionID).setPermissions(input),
      move: moves.move,
      compact: (input) => sessions.forSession(input.sessionID).compact(input),
@@ -131,7 +131,6 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
          )
        }),
      "session.renamed": () => Effect.void,
-      "session.metadata.updated": () => Effect.void,
      "session.permissions": () => Effect.void,
      "session.deleted": () => Effect.void,
      "session.forked": () => Effect.void,
@@ -20,9 +20,10 @@ import { SessionSchema } from "./schema.js"
 import { webSocketConstructor } from "../effect/app-node-platform.js"

 const ROTATE_AFTER_MS = 55 * 60 * 1000
-const INBOUND_CAPACITY = 128
-const CONNECT_TIMEOUT = "10 seconds"
+const CONNECT_TIMEOUT = "15 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,
@@ -50,6 +51,7 @@ interface State {
  readonly lock: Semaphore.Semaphore
  closed: boolean
  httpFallback: boolean
+  streamFailures: number
  channel?: Channel
 }

@@ -126,7 +128,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 }
+        const created = { lock: Semaphore.makeUnsafe(1), closed: false, httpFallback: false, streamFailures: 0 }
        states.set(sessionID, created)
        return created
      }
@@ -168,15 +170,27 @@ 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* metric(
-          error.reason._tag === "Transport" && error.reason.code === "queue-overflow"
-            ? "queue_overflow"
-            : "protocol_failure",
-        )
+        if (channel.active) {
+          Queue.failCauseUnsafe(channel.active.queue, Cause.fail(error))
+          yield* streamFailure(owner)
+        }
+        yield* metric("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,
@@ -235,14 +249,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
                      code: "message",
                      phase: "receive",
                    })
-                  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",
-                  })
+                  Queue.offerUnsafe(active.queue, message)
                }),
              ),
              Effect.catch((error) =>
@@ -255,9 +262,7 @@ 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" ||
-                          (error.reason._tag === "Transport" && error.reason.code === "queue-overflow")
+                          channel.active?.delivery === "provider-observed" || channel.active?.delivery === "terminal"
                            ? "accepted"
                            : error.reason._tag === "Transport" && error.reason.code === "1009"
                              ? "rejected"
@@ -370,7 +375,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
          mode: create.mode,
        })
        const active: Active = {
-          queue: yield* Queue.bounded<string, AIError>(INBOUND_CAPACITY),
+          queue: yield* Queue.unbounded<string, AIError>(),
          delivery: "send-attempted",
        }
        channel.active = active
@@ -395,6 +400,7 @@ 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")
@@ -435,6 +441,7 @@ 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
@@ -573,14 +573,6 @@ const layer = Layer.effectDiscard(
        .run()
        .pipe(Effect.orDie),
    )
-    yield* bus.project(SessionEvent.MetadataUpdated, (event) =>
-      db
-        .update(SessionTable)
-        .set({ metadata: event.data.metadata, time_updated: event.created })
-        .where(eq(SessionTable.id, event.data.sessionID))
-        .run()
-        .pipe(Effect.orDie),
-    )
    yield* bus.project(SessionEvent.Permissions, (event) =>
      db
        .update(SessionTable)
@@ -73,13 +73,6 @@ export const make = Effect.fn("Session.make")(function* () {
    yield* get(sessionID)
    yield* bus.publish(SessionEvent.Renamed, { sessionID, title: input.title })
  })
-  const setMetadata = Effect.fn("Session.setMetadata")(function* (
-    sessionID: SessionSchema.ID,
-    input: { metadata: SessionSchema.Metadata },
-  ) {
-    yield* get(sessionID)
-    yield* bus.publish(SessionEvent.MetadataUpdated, { sessionID, metadata: input.metadata })
-  })
  const setPermissions = Effect.fn("Session.setPermissions")(function* (
    sessionID: SessionSchema.ID,
    input: { permissions: Permission.Ruleset },
@@ -349,7 +342,6 @@ export const make = Effect.fn("Session.make")(function* () {
    message,
    view,
    rename,
-    setMetadata,
    setPermissions,
    switchAgent,
    switchModel,
@@ -373,7 +365,6 @@ export const make = Effect.fn("Session.make")(function* () {
    const message = operations.message.bind(undefined, sessionID)
    const view = operations.view.bind(undefined, sessionID)
    const rename = operations.rename.bind(undefined, sessionID)
-    const setMetadata = operations.setMetadata.bind(undefined, sessionID)
    const setPermissions = operations.setPermissions.bind(undefined, sessionID)
    const switchAgent = operations.switchAgent.bind(undefined, sessionID)
    const switchModel = operations.switchModel.bind(undefined, sessionID)
@@ -400,7 +391,6 @@ export const make = Effect.fn("Session.make")(function* () {
      message,
      view,
      rename,
-      setMetadata,
      setPermissions,
      switchAgent,
      switchModel,
@@ -290,6 +290,37 @@ 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
@@ -8,7 +8,7 @@ import { Money } from "@opencode/schema/money"
 import { Shell } from "@opencode/schema/shell"
 import { Skill } from "@opencode/schema/skill"
 import { Agent } from "@opencode/core/agent"
-import { and, asc, eq } from "drizzle-orm"
+import { asc, eq } from "drizzle-orm"
 import { Database } from "@opencode/core/database/database"
 import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder"
 import { LayerNode } from "@opencode/util/effect/layer-node"
@@ -385,26 +385,6 @@ describe("Session.create", () => {

      // Absent stays absent: no empty-object normalization.
      expect((yield* session.create({ location })).metadata).toBeUndefined()
-
-      const replacement = { thread: "updated", owner: "host" }
-      yield* session.setMetadata({ sessionID: created.id, metadata: replacement })
-      expect((yield* session.get(created.id)).metadata).toEqual(replacement)
-      expect(
-        yield* db
-          .select({ data: EventTable.data })
-          .from(EventTable)
-          .where(
-            and(
-              eq(EventTable.aggregate_id, created.id),
-              eq(EventTable.type, Bus.versionedType(SessionEvent.MetadataUpdated.type, 1)),
-            ),
-          )
-          .get()
-          .pipe(Effect.orDie),
-      ).toMatchObject({ data: { metadata: replacement } })
-      expect(
-        yield* session.setMetadata({ sessionID: Session.ID.create(), metadata: replacement }).pipe(Effect.flip),
-      ).toBeInstanceOf(Session.NotFoundError)
    }),
  )

@@ -593,7 +593,7 @@ describe("SessionModelTransport", () => {
          Effect.forkChild({ startImmediately: true }),
        )
        yield* Effect.yieldNow
-        yield* TestClock.adjust("10 seconds")
+        yield* TestClock.adjust("15 seconds")
        expect(yield* Fiber.join(running)).toEqual(["fallback:slow"])
      }),
    )
@@ -731,6 +731,40 @@ 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
@@ -915,24 +949,22 @@ describe("SessionModelTransport", () => {
    )
  })

-  test("poisons instead of dropping data when the inbound queue overflows", async () => {
+  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
    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 <= 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,
-          ),
+              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),
        }),
    }

@@ -941,20 +973,21 @@ describe("SessionModelTransport", () => {
      Effect.gen(function* () {
        const transport = yield* SessionModelTransport.Service
        const item = exchange("first")
-        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" } },
+        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 },
+              ),
+          },
        })
-        expect(closed).toBe(1)
+        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)
      }),
    )
  })
@@ -28,6 +28,29 @@ const sentry =
      })
    : false

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

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

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

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

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

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

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

@@ -157,6 +158,7 @@ export const layer = Layer.unwrap(
    // Decide first-launch state before the storage layer creates drafts.sqlite, which would
    // otherwise read as evidence of an earlier launch on a fresh install.
    yield* initializeFirstLaunchOnboarding(app.getPath("userData"))
+    marks.onboarding = Date.now()
    return runtime.pipe(Layer.provideMerge(platform))
  }),
 )
@@ -1,4 +1,7 @@
 // Startup marks, epoch ms. The entry module records them before any logger exists; the logging
-// layer reports them with "app starting" so the startup benchmark can split the time before the
-// first log line into Electron's own initialisation, our entry, and the main bundle.
-export const marks: { entry: number; ready?: number; window?: number; bundle?: number } = { entry: Date.now() }
+// layer reports the early ones with "app starting" and the rest with "layers ready", so the startup
+// benchmark can split the time before the renderer gets its IPC port into Electron's own
+// initialisation, our entry, the main bundle and each layer.
+export const marks: { entry: number } & Partial<
+  Record<"ready" | "window" | "served" | "bundle" | "onboarding" | "logging" | "crash" | "storage" | "init" | "layers", number>
+> = { entry: Date.now() }
@@ -8,6 +8,10 @@ import { getStore } from "../storage/store"
 const DEFAULT_PROJECT_DIR = "Default Project"

 export const initializeFirstLaunchOnboarding = Effect.fn("Onboarding.initialize")(function* (userDataPath: string) {
+  const store = getStore()
+  const current = store.get(FIRST_LAUNCH_ONBOARDING_COMPLETE_KEY)
+  if (typeof current === "boolean") return current
+
  const fs = yield* FileSystem.FileSystem
  const path = yield* Path.Path
  const names = (yield* fs.exists(userDataPath)) ? yield* fs.readDirectory(userDataPath) : []
@@ -17,11 +21,8 @@ export const initializeFirstLaunchOnboarding = Effect.fn("Onboarding.initialize"
      const info = yield* fs.stat(path.join(userDataPath, name)).pipe(Effect.option)
      return { name, directory: Option.isSome(info) && info.value.type === "Directory" }
    }),
+    { concurrency: "unbounded" },
  )
-  const store = getStore()
-  const current = store.get(FIRST_LAUNCH_ONBOARDING_COMPLETE_KEY)
-  if (typeof current === "boolean") return current
-
  const complete = hasExistingAppState(entries)
  store.set(FIRST_LAUNCH_ONBOARDING_COMPLETE_KEY, complete)
  return complete
@@ -19,6 +19,7 @@ let netLogPath: string | undefined

 export interface Interface {
  readonly startNetwork: Effect.Effect<void>
+  readonly startCrashReporter: Effect.Effect<void>
  readonly exportDebug: Effect.Effect<string>
 }

@@ -30,7 +31,9 @@ const serviceLayer = Layer.effect(
    const fs = yield* FileSystem.FileSystem
    const path = yield* Path.Path
    yield* initLogging(fs, path).pipe(Effect.orDie)
-    yield* initCrashReporter(fs, path).pipe(Effect.orDie)
+    // Old run directories go away in the background; listing them is not worth a wait at startup.
+    yield* Effect.forkScoped(cleanup(fs, path).pipe(Effect.catch(() => Effect.void)))
+    marks.logging = Date.now()
    yield* Effect.logInfo("app starting", {
      version: VERSION,
      packaged: app.isPackaged,
@@ -42,6 +45,12 @@ const serviceLayer = Layer.effect(
      startNetwork: startNetLog(path).pipe(
        Effect.catch((error) => Effect.logWarning("failed to start net log", { error })),
      ),
+      // Starting crashpad spawns its handler process, ~60 ms on the main thread, so the first window
+      // and its IPC port come first.
+      startCrashReporter: initCrashReporter(fs, path).pipe(
+        Effect.tap(() => Effect.sync(() => (marks.crash = Date.now()))),
+        Effect.catch((error) => Effect.logWarning("failed to start crash reporter", { error })),
+      ),
      exportDebug,
    })
  }),
@@ -99,7 +108,6 @@ function initLogging(fs: FileSystem.FileSystem, path: Path.Path) {
      log.initialize({ preload: false, spyRendererConsole: true })
      initConsoleTransport()
    })
-    yield* cleanup(fs, path)
  })
 }

@@ -3,6 +3,7 @@ import { Context, Effect, FileSystem, Layer, Path } from "effect"
 import { BackgroundServiceState } from "./background-service-state"
 import { cleanStages, DesktopCli } from "./desktop-cli"
 import { SidecarCredentials } from "./sidecar-credentials"
+import { sidecarProbe } from "./sidecar-probe"

 export * as BackgroundService from "./background-service"

@@ -36,7 +37,7 @@ const connect = Effect.fn("BackgroundService.connect")(function* (mode: "initial
  const version = mode === "initial" ? cli.version : undefined
  if (isolated) process.env.XDG_STATE_HOME = app.getPath("userData")
  const client = yield* Effect.promise(() => import("@opencode/client/service"))
-  const service = yield* Effect.tryPromise(() =>
+  const ensure = () =>
    client.Service.ensure({
      file:
        isolated && process.env.OPENCODE_DESKTOP_SERVER_CHANNEL === "local"
@@ -46,13 +47,18 @@ const connect = Effect.fn("BackgroundService.connect")(function* (mode: "initial
      command: [...cli.command, "serve", "--service", ...(isolated ? ["--port", "0"] : [])],
      onStart: (reason, previousVersion) =>
        runFork(Effect.logInfo("v2 CLI background service starting", { reason, previousVersion })),
-    }),
-  )
+    })
+  // A compatible service the entry module already found is adopted at once; ensure() still runs
+  // afterwards for its side effects (terminal handoff completion), off the renderer's path.
+  const early = mode === "initial" && !isolated ? yield* Effect.promise(sidecarProbe) : undefined
+  if (early) yield* Effect.sync(() => void ensure().catch(() => undefined))
+  const service = early ?? (yield* Effect.tryPromise(ensure))
  if (service.auth?.type !== "basic") throw new Error("V2 CLI background service did not provide authentication")
  const url = new URL(service.url)
  if (url.hostname === "0.0.0.0") url.hostname = "127.0.0.1"
  yield* Effect.logInfo("v2 CLI background service ready", {
    version,
+    probed: !!early,
    ...endpoint(url.origin),
  })
  if (mode === "initial" && isolated && cli.binary) yield* cleanStages(cli.binary).pipe(Effect.orDie)
@@ -1,6 +1,7 @@
 export * as DesktopCli from "./desktop-cli"

 import { execFile, spawn } from "node:child_process"
+import { existsSync, readFileSync } from "node:fs"
 import { promisify } from "node:util"
 import { app } from "electron"
 import { Context, Effect, FileSystem, Layer, Option, Path } from "effect"
@@ -93,9 +94,15 @@ const resolveBundledCli = Effect.fn("DesktopCli.resolveBundled")(function* (isol
 const bundledVersion = Effect.fn("DesktopCli.bundledVersion")(function* (bundled: string) {
  const fs = yield* FileSystem.FileSystem
  const path = yield* Path.Path
-  const shipped = yield* fs
-    .readFileString(path.join(path.dirname(bundled), "opencode-cli.version"))
-    .pipe(Effect.map((text) => text.trim()), Effect.orElseSucceed(() => ""))
+  // Synchronous on purpose: this sits on the path to the first window's IPC port, and a queued
+  // async read waits behind everything else the main thread is doing at that moment.
+  const shipped = yield* Effect.sync(() => {
+    try {
+      return readFileSync(path.join(path.dirname(bundled), "opencode-cli.version"), "utf8").trim()
+    } catch {
+      return ""
+    }
+  })
  if (shipped) {
    yield* Effect.logInfo("v2 CLI version bundled", { version: shipped })
    return shipped
@@ -147,7 +154,7 @@ const installCli = Effect.fn("DesktopCli.install")(function* (source: string, ve
  const path = yield* Path.Path
  const directory = path.join(app.getPath("userData"), "cli", version.replace(/[^a-zA-Z0-9._-]/g, "-"))
  const destination = path.join(directory, executableName())
-  if (yield* fs.exists(destination)) {
+  if (existsSync(destination)) {
    yield* Effect.logInfo("v2 CLI staged executable reused", { path: destination, version })
    return destination
  }
@@ -0,0 +1,32 @@
+import { readFileSync } from "node:fs"
+import path from "node:path"
+import { app } from "electron"
+import type { Endpoint } from "@opencode/client/service"
+
+// The main thread idles between showing the first window and evaluating the main bundle, waiting
+// for the renderer's asset requests. That slot is long enough to find out whether a compatible
+// background service is already running, so the renderer's first data request is not the first
+// moment anyone asks. The probe only looks; a service that has to be started waits for the layers,
+// which set the environment the CLI expects.
+let probe: Promise<Endpoint | undefined> | undefined
+
+export function startSidecarProbe() {
+  if (!app.isPackaged) return
+  const version = bundledVersion()
+  if (!version) return
+  probe = import("@opencode/client/service")
+    .then(({ Service }) => Service.discover({ version }))
+    .catch(() => undefined)
+}
+
+export function sidecarProbe() {
+  return probe ?? Promise.resolve(undefined)
+}
+
+function bundledVersion() {
+  try {
+    return readFileSync(path.join(process.resourcesPath, "opencode-cli.version"), "utf8").trim()
+  } catch {
+    return ""
+  }
+}
@@ -2,7 +2,9 @@ export * as DesktopStorage from "./index"

 import { app, BrowserWindow } from "electron"
 import { Context, Effect, Layer, Path } from "effect"
+import { marks } from "../lifecycle/marks"
 import { openDatabase } from "./database"
+import { setStorageSnapshotProvider } from "./snapshot"
 import { createDraftStore } from "./drafts"
 import { importLegacyStores } from "./legacy"
 import { createStateStore } from "./state"
@@ -40,6 +42,8 @@ export const layer = Layer.effect(
        storage.close()
      }),
    )
+    setStorageSnapshotProvider((names) => Object.fromEntries(names.map((name) => [name, storage.state.items(name)])))
+    marks.storage = Date.now()
    return Service.of(storage)
  }),
 )
@@ -0,0 +1,56 @@
+import { existsSync, readdirSync } from "node:fs"
+import path from "node:path"
+import { DatabaseSync } from "node:sqlite"
+import { app, ipcMain } from "electron"
+import { StorageSnapshotChannel, type StorageSnapshot } from "../../shared/ipc-transport"
+import { isRendererUrl } from "../windows/scheme"
+
+// A window's preload asks for the namespaces its shell reads before the page runs, so the first
+// render is the hydrated one. Until the storage layer is up (the first window asks before it exists)
+// the answer comes from the database file; the layer takes over so later windows see queued writes.
+type Provider = (names: ReadonlyArray<string>) => StorageSnapshot
+
+let provider: Provider = readFromDisk
+
+export function setStorageSnapshotProvider(next: Provider) {
+  provider = next
+}
+
+export function registerStorageSnapshotHandler() {
+  ipcMain.handle(StorageSnapshotChannel, (event, names: unknown): StorageSnapshot => {
+    if (!isRendererUrl(event.senderFrame?.url)) return {}
+    if (!Array.isArray(names)) return {}
+    return provider(names.filter((name): name is string => typeof name === "string"))
+  })
+}
+
+// Nothing has been written in this process yet, so every namespace is at revision 0, as the
+// storage layer would report before its first update. Legacy electron-store files still waiting
+// to be imported would make the database stale for this launch, so the renderer asks the layer then.
+function readFromDisk(names: ReadonlyArray<string>): StorageSnapshot {
+  const userData = app.getPath("userData")
+  const file = path.join(userData, "drafts.sqlite")
+  if (!existsSync(file)) return {}
+  if (readdirSync(userData).some((name) => name === "default.dat" || /^opencode\..+\.dat$/.test(name))) return {}
+  try {
+    const db = new DatabaseSync(file)
+    try {
+      const rows = db.prepare("SELECT key, value FROM state WHERE name = ?")
+      return Object.fromEntries(
+        names.map((name) => [
+          name,
+          {
+            items: Object.fromEntries(
+              (rows.all(name) as { key: string; value: string }[]).map((row) => [row.key, row.value]),
+            ),
+            revision: 0,
+          },
+        ]),
+      )
+    } finally {
+      db.close()
+    }
+  } catch {
+    return {}
+  }
+}
@@ -0,0 +1,20 @@
+import { windowBootstrapArgument, type WindowBootstrap } from "../../shared/window-bootstrap"
+import { getDefaultServerUrl } from "../service/server-settings"
+import { FIRST_LAUNCH_ONBOARDING_COMPLETE_KEY } from "../storage/keys"
+import { getStore } from "../storage/store"
+
+// The settings store is already in memory when a window is created, so the renderer gets the
+// answers its shell gate would otherwise ask for over IPC. A fresh install has no onboarding
+// decision yet; the renderer asks once the layers have made one.
+export function windowBootstrap(id: string): WindowBootstrap {
+  const complete = getStore().get(FIRST_LAUNCH_ONBOARDING_COMPLETE_KEY)
+  return {
+    id,
+    firstLaunchPending: typeof complete === "boolean" ? !complete : undefined,
+    defaultServerUrl: getDefaultServerUrl(),
+  }
+}
+
+export function windowArguments(id: string) {
+  return [windowBootstrapArgument(windowBootstrap(id))]
+}
@@ -9,10 +9,6 @@ import { getStore } from "../storage/store"
 // full window setup in appearance.ts, so both draw the same frame.

 const oc2Theme = oc2ThemeJson as DesktopTheme
-const oc2Background = {
-  light: resolveThemeVariant(oc2Theme.light, false)["background-base"],
-  dark: resolveThemeVariant(oc2Theme.dark, true)["background-base"],
-}
 // Match the renderer's 36px titlebar plus its former 8px content inset.
 export const titlebarHeight = 44

@@ -21,10 +17,13 @@ export function tone() {
 }

 // The colour the renderer reported on its last run, or the default theme's for the system tone, so
-// a window shown before the renderer paints already has the right background.
+// a window shown before the renderer paints already has the right background. Resolving a palette
+// costs tens of milliseconds before the first window, so it only happens when nothing is stored.
 export function storedBackgroundColor() {
  const stored = getStore().get(BACKGROUND_COLOR_KEY)
-  return typeof stored === "string" ? stored : oc2Background[tone()]
+  if (typeof stored === "string") return stored
+  const dark = tone() === "dark"
+  return resolveThemeVariant(dark ? oc2Theme.dark : oc2Theme.light, dark)["background-base"]
 }

 export function titlebarOverlay(mode: "light" | "dark" = tone(), zoom = 1) {
@@ -1,14 +1,25 @@
 import { randomUUID } from "node:crypto"
 import path from "node:path"
 import { fileURLToPath } from "node:url"
-import { app, BrowserWindow, screen } from "electron"
-import { windowIDArgument } from "../../shared/window-bootstrap"
+import { app, BrowserWindow, screen, shell } from "electron"
+import { resolveExternalURL } from "../files/external-url"
+import { windowArguments } from "./bootstrap"
 import { WINDOW_IDS_KEY } from "../storage/keys"
 import { getStore } from "../storage/store"
 import { storedBackgroundColor, titlebarOverlay } from "./defaults"
+import { registerRendererProtocol } from "./protocol"
+import { loadWindow } from "./scheme"
+import { allowRendererPermissions, wireNavigationPolicy, wireRendererHeaders } from "./security"
 import { manageWindowState, readWindowState, resolveWindowState, windowStateFile, type WindowState } from "./window-state"

-export type EarlyWindow = { id: string; win: BrowserWindow; state: WindowState; shownAt: number }
+export type EarlyWindow = {
+  id: string
+  win: BrowserWindow
+  state: WindowState
+  shownAt: number
+  // Navigation policy is wired before the layers exist; the adopter swaps in the logged version.
+  openExternal: (url: string) => void
+}

 let pending: EarlyWindow | undefined

@@ -46,7 +57,7 @@ export function createEarlyWindow() {
      contextIsolation: true,
      nodeIntegration: false,
      sandbox: true,
-      additionalArguments: [windowIDArgument(id)],
+      additionalArguments: windowArguments(id),
    },
  })
  manageWindowState(win, file, state, displays)
@@ -56,7 +67,24 @@ export function createEarlyWindow() {
    pending = undefined
    app.quit()
  })
-  pending = { id, win, state, shownAt: Date.now() }
+  const record: EarlyWindow = {
+    id,
+    win,
+    state,
+    shownAt: Date.now(),
+    openExternal: (url) => {
+      const target = resolveExternalURL(url)
+      if (target) void shell.openExternal(target)
+    },
+  }
+  pending = record
+  // The renderer boots while the main bundle and layers load, instead of after them. Everything the
+  // page needs before its first request is wired here; the IPC port arrives once the layers are up.
+  registerRendererProtocol(path.join(root, "../renderer"))
+  allowRendererPermissions(win)
+  wireNavigationPolicy(win, (url) => record.openExternal(url))
+  wireRendererHeaders(win)
+  loadWindow(win, "index.html")
 }

 export function takeEarlyWindow() {
@@ -7,7 +7,8 @@ import { DesktopPaths } from "../paths"
 import { DesktopStorage } from "../storage"
 import { getStore } from "../storage/store"
 import { WINDOW_IDS_KEY } from "../storage/keys"
-import { windowIDArgument } from "../../shared/window-bootstrap"
+import { windowDataFile } from "../../shared/ipc-transport"
+import { windowArguments } from "./bootstrap"
 import {
  getBackgroundColor,
  getPinchZoomEnabled,
@@ -21,7 +22,8 @@ import {
  wireFullscreen,
  wireZoom,
 } from "./appearance"
-import { loadWindow, registerRendererProtocol } from "./protocol"
+import { registerRendererProtocol, setProtocolReporter } from "./protocol"
+import { loadWindow } from "./scheme"
 import { createWindowRegistry } from "./registry"
 import { makeWindowRecovery } from "./recovery"
 import { takeEarlyWindow, type EarlyWindow } from "./early"
@@ -48,6 +50,7 @@ export {
  getBackgroundColor,
  getPinchZoomEnabled,
  registerRendererProtocol,
+  setProtocolReporter,
  setBackgroundColor,
  setDockIcon,
  setPinchZoomEnabled,
@@ -115,18 +118,23 @@ export const makeMainWindows = Effect.fn("Window.make")(function* () {
        ...appearance,
        webPreferences: {
          ...appearance.webPreferences,
-          additionalArguments: [windowIDArgument(id)],
+          additionalArguments: windowArguments(id),
        },
      })

-    allowRendererPermissions(win)
+    // The early window was secured and loaded when it was created; only its external-URL policy is
+    // upgraded to the logged one.
+    if (early) early.openExternal = (url) => runFork(openExternalURL(url))
+    if (!early) {
+      allowRendererPermissions(win)
+      wireNavigationPolicy(win, (url) => runFork(openExternalURL(url)))
+      wireRendererHeaders(win)
+      manageWindowState(win, stateFile, state, displays)
+    }
    wireWindowRecovery(win, id, () => relaunchHandler())
-    wireNavigationPolicy(win, (url) => runFork(openExternalURL(url)))
-    wireRendererHeaders(win)
-    if (!early) manageWindowState(win, stateFile, state, displays)
    register(win, id)
    wireFullscreen(win)
-    loadWindow(win, "index.html")
+    if (!early) loadWindow(win, "index.html")
    wireZoom(win)
    let contentReady = false
    let appliedTheme = false
@@ -182,12 +190,4 @@ export const makeMainWindows = Effect.fn("Window.make")(function* () {
  return { create, restore }
 })

-// Mirrors windowStorage() in packages/app/src/runtime/persistence/storage.ts; it is the state
-// namespace the renderer persists this window's tabs under.
-function windowDataFile(id: string) {
-  return `opencode.window.${safeWindowID(id)}.dat`
-}

-function safeWindowID(id: string) {
-  return id.replace(/[^a-zA-Z0-9._-]/g, "-")
-}
@@ -1,73 +1,85 @@
 import { net, protocol } from "electron"
-import type { BrowserWindow } from "electron"
+import path from "node:path"
 import { pathToFileURL } from "node:url"
-import { Effect, Path } from "effect"
-import { scoped } from "../native/logging"
-import { DesktopPaths } from "../paths"
 import { documentPolicyHeader, jsCallStacksDocumentPolicy } from "./headers"
 import { rendererHost, rendererProtocol } from "./scheme"

-export const registerRendererProtocol = Effect.fn("Window.registerRendererProtocol")(function* () {
-  const path = yield* Path.Path
-  const paths = yield* DesktopPaths.resolve
-  const runFork = Effect.runForkWith(yield* Effect.context<never>())
+export type ProtocolReport = (level: "warning" | "error", message: string, data: Record<string, unknown>) => void
+
+// The entry module registers the handler the moment the first window exists, before logging is up,
+// so problems go to the console until the logging layer installs a reporter.
+let report: ProtocolReport = (level, message, data) => console[level === "error" ? "error" : "warn"](message, data)
+
+export function setProtocolReporter(reporter: ProtocolReport) {
+  report = reporter
+}
+
+// Requests in flight and when the last one arrived. The entry module holds the main bundle back
+// until the renderer's initial burst of asset requests has been answered, because this handler
+// runs on the main thread and a 100 ms module evaluation would otherwise sit between the renderer
+// and its HTML.
+let inflight = 0
+let served = 0
+let lastRequest = 0
+
+export function rendererAssetsServed(options: { quietMs: number; capMs: number }) {
+  const start = Date.now()
+  return new Promise<void>((resolve) => {
+    const check = () => {
+      const now = Date.now()
+      if (now - start >= options.capMs) return resolve()
+      if (served > 0 && inflight === 0 && now - lastRequest >= options.quietMs) return resolve()
+      setTimeout(check, 5)
+    }
+    check()
+  })
+}
+
+export function registerRendererProtocol(rendererRoot: string) {
  if (protocol.isProtocolHandled(rendererProtocol)) return

  protocol.handle(rendererProtocol, async (request) => {
-    const url = new URL(request.url)
-    if (url.host !== rendererHost) {
-      runFork(scoped("protocol", Effect.logWarning("rejected host", { url: request.url })))
-      return new Response("Not found", { status: 404 })
-    }
-
-    const file = path.resolve(paths.rendererRoot, `.${decodeURIComponent(url.pathname)}`)
-    const rel = path.relative(paths.rendererRoot, file)
-    if (rel.startsWith("..") || path.isAbsolute(rel)) {
-      runFork(scoped("protocol", Effect.logWarning("rejected path", { url: request.url, file })))
-      return new Response("Not found", { status: 404 })
-    }
-
+    inflight++
+    lastRequest = Date.now()
    try {
-      const range = request.headers.get("range")
-      const response = await net.fetch(pathToFileURL(file).toString(), { headers: range ? { range } : undefined })
-      if (response.status >= 400) {
-        runFork(
-          scoped(
-            "protocol",
-            Effect.logError("fetch failed", {
-              url: request.url,
-              file,
-              status: response.status,
-              statusText: response.statusText,
-            }),
-          ),
-        )
-      }
-      return addDocumentPolicy(response, file)
-    } catch (error) {
-      runFork(scoped("protocol", Effect.logError("fetch error", { url: request.url, file, error })))
-      return new Response("Not found", { status: 404 })
+      return await serve(request, rendererRoot)
+    } finally {
+      inflight--
+      served++
    }
  })
-})
-
-export function loadWindow(win: BrowserWindow, html: string) {
-  const devUrl = process.env.ELECTRON_RENDERER_URL
-  if (devUrl) {
-    void win.loadURL(new URL(html, devUrl).toString())
-    return
-  }
-  void win.loadURL(`${rendererProtocol}://${rendererHost}/${html}`)
 }

-export function isRendererUrl(value?: string, html = false) {
-  if (!value || !URL.canParse(value)) return false
-  const url = new URL(value)
-  if (html && !url.pathname.endsWith(".html")) return false
-  if (url.protocol === `${rendererProtocol}:` && url.host === rendererHost) return true
-  const devUrl = process.env.ELECTRON_RENDERER_URL
-  if (!devUrl || !URL.canParse(devUrl)) return false
-  return url.origin === new URL(devUrl).origin
+async function serve(request: Request, rendererRoot: string) {
+  const url = new URL(request.url)
+  if (url.host !== rendererHost) {
+    report("warning", "rejected host", { url: request.url })
+    return new Response("Not found", { status: 404 })
+  }
+
+  const file = path.resolve(rendererRoot, `.${decodeURIComponent(url.pathname)}`)
+  const rel = path.relative(rendererRoot, file)
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    report("warning", "rejected path", { url: request.url, file })
+    return new Response("Not found", { status: 404 })
+  }
+
+  try {
+    const range = request.headers.get("range")
+    const response = await net.fetch(pathToFileURL(file).toString(), { headers: range ? { range } : undefined })
+    if (response.status >= 400) {
+      report("error", "fetch failed", {
+        url: request.url,
+        file,
+        status: response.status,
+        statusText: response.statusText,
+      })
+    }
+    return addDocumentPolicy(response, file)
+  } catch (error) {
+    report("error", "fetch error", { url: request.url, file, error })
+    return new Response("Not found", { status: 404 })
+  }
 }

 function addDocumentPolicy(response: Response, file: string) {
@@ -1,8 +1,28 @@
 import { protocol } from "electron"
+import type { BrowserWindow } from "electron"

 export const rendererProtocol = "oc"
 export const rendererHost = "renderer"

+export function loadWindow(win: BrowserWindow, html: string) {
+  const devUrl = process.env.ELECTRON_RENDERER_URL
+  if (devUrl) {
+    void win.loadURL(new URL(html, devUrl).toString())
+    return
+  }
+  void win.loadURL(`${rendererProtocol}://${rendererHost}/${html}`)
+}
+
+export function isRendererUrl(value?: string, html = false) {
+  if (!value || !URL.canParse(value)) return false
+  const url = new URL(value)
+  if (html && !url.pathname.endsWith(".html")) return false
+  if (url.protocol === `${rendererProtocol}:` && url.host === rendererHost) return true
+  const devUrl = process.env.ELECTRON_RENDERER_URL
+  if (!devUrl || !URL.canParse(devUrl)) return false
+  return url.origin === new URL(devUrl).origin
+}
+
 // Scheme privileges can only be granted before the app is ready, so the entry module calls this
 // before it loads anything else.
 export function registerRendererScheme() {
@@ -1,7 +1,7 @@
 import type { BrowserWindow } from "electron"
 import { SidecarCredentials } from "../service/sidecar-credentials"
 import { addRendererHeaders, hasHeader, upsertHeader } from "./headers"
-import { isRendererUrl } from "./protocol"
+import { isRendererUrl } from "./scheme"

 const rendererPermissions = new Set(["clipboard-sanitized-write", "notifications"])

@@ -1,6 +1,12 @@
 import { contextBridge, ipcRenderer, webUtils } from "electron"
-import { DragCancelEvent, IpcTransportPort } from "../shared/ipc-transport"
-import { windowIDFromArguments } from "../shared/window-bootstrap"
+import {
+  DragCancelEvent,
+  IpcTransportPort,
+  StorageSnapshotChannel,
+  storageSnapshotNames,
+  type StorageSnapshot,
+} from "../shared/ipc-transport"
+import { windowBootstrapFromArguments } from "../shared/window-bootstrap"

 ipcRenderer.on(IpcTransportPort, (event) => {
  const port = event.ports[0]
@@ -9,7 +15,15 @@ ipcRenderer.on(IpcTransportPort, (event) => {

 ipcRenderer.on(DragCancelEvent, () => window.dispatchEvent(new Event(DragCancelEvent)))

+const bootstrap = windowBootstrapFromArguments(process.argv)
+// Asked before the page runs, so the stores the shell reads are hydrated on the first render.
+const storageSnapshot: Promise<StorageSnapshot> = ipcRenderer
+  .invoke(StorageSnapshotChannel, storageSnapshotNames(bootstrap.id))
+  .catch(() => ({}))
+
 contextBridge.exposeInMainWorld("electron", {
-  windowID: windowIDFromArguments(process.argv),
+  windowID: bootstrap.id,
+  bootstrap,
+  storageSnapshot,
  getPathForFile: (file: File) => webUtils.getPathForFile(file),
 })
@@ -1,4 +1,9 @@
+import type { StorageSnapshot } from "../shared/ipc-transport"
+import type { WindowBootstrap } from "../shared/window-bootstrap"
+
 export type ElectronNative = {
  windowID: string
+  bootstrap: WindowBootstrap
+  storageSnapshot: Promise<StorageSnapshot>
  getPathForFile(file: File): string
 }
@@ -5,6 +5,7 @@ import type { UpdaterState } from "@opencode/app/updater"
 import type { WslServersPlatform } from "@opencode/app/wsl/types"
 import type { SshPlatform } from "@opencode/app/ssh"
 import type { BrowserPaneRequest } from "../shared/ipc-rpc/browser"
+import type { WindowBootstrap } from "../shared/window-bootstrap"
 import type {
  ClipboardImage,
  DirectoryPickerOptions,
@@ -53,6 +54,7 @@ export type ElectronAPI = {
  draftBlobPut(data: ArrayBuffer): Promise<string>
  draftBlobGet(id: string): Promise<ArrayBuffer | null>
  getWindowID(): string
+  getWindowBootstrap(): WindowBootstrap
  themeReady(): Promise<void>
  onMenuCommand(cb: (id: string) => void): () => void
  onDeepLink(cb: (urls: string[]) => void): () => void
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
opencode-agent[bot]	1f8ab95695	chore(core): refresh bundled models.dev snapshot	2026-09-20 15:37:06 +00:00
Aiden Cline	62dc1f7696	feat(codemode): add toLocaleString, Error.isError, and Map.getOrInsert (#50098 )	2026-09-20 10:23:23 -05:00
opencode-agent[bot]	66f10ab7bf	chore(core): refresh bundled models.dev snapshot	2026-09-20 14:37:06 +00:00
opencode-agent[bot]	1ca8f63a79	chore(core): refresh bundled models.dev snapshot	2026-09-20 13:36:51 +00:00
opencode-agent[bot]	03bcdd580d	chore(core): refresh bundled models.dev snapshot	2026-09-20 12:43:39 +00:00
opencode-agent[bot]	cc502f7e5f	chore(core): refresh bundled models.dev snapshot	2026-09-20 11:37:37 +00:00
opencode-agent[bot]	64ce8771c0	chore(core): refresh bundled models.dev snapshot	2026-09-20 10:37:01 +00:00
opencode-agent[bot]	702a73d91a	chore(core): refresh bundled models.dev snapshot	2026-09-20 09:37:50 +00:00
opencode	991b727eb8	sync release versions for v2.0.11	2026-09-20 08:57:41 +00:00
opencode-agent[bot]	ba342ce227	chore(core): refresh bundled models.dev snapshot	2026-09-20 08:42:13 +00:00
David Hill	1464545665	fix(app): center timeline beside summary (#49620 )	2026-09-20 18:06:32 +10:00
David Hill	fecacc9e68	fix(app): match vertical nav tab states (#49619 )	2026-09-20 18:03:49 +10:00
David HillandLukeParkerDev	1f73b4806b	fix(desktop): polish browser panel states and navigation (#49432 ) Co-authored-by: LukeParkerDev <10430890+Hona@users.noreply.github.com>	2026-09-20 07:54:25 +00:00
opencode-agent[bot]	da2ce02596	chore(core): refresh bundled models.dev snapshot	2026-09-20 07:38:48 +00:00
opencode-agent[bot]	25f35dcfb8	chore(core): refresh bundled models.dev snapshot	2026-09-20 06:49:40 +00:00
Luke Parker	717f81ce08	chore(desktop): attribute renderer CPU profiles to source files (#50114 )	2026-09-20 16:30:35 +10:00
Luke Parker	5fdfcc7a80	perf(desktop): hand the window its persisted stores before the first render (#50113 )	2026-09-20 16:29:02 +10:00
Luke Parker	0530c8e512	perf(desktop): talk to the main process without the Effect runtime in the renderer (#50112 )	2026-09-20 16:26:08 +10:00
Luke Parker	1d8cf4564b	perf(desktop): move startup work that the first window does not need off its path (#50111 )	2026-09-20 16:23:37 +10:00
Luke Parker	7e88f6bb18	perf(desktop): bundle the renderer's initial module graph as one chunk (#50110 )	2026-09-20 16:19:28 +10:00
Luke Parker	af592fb779	perf(desktop): serve the renderer's first assets before evaluating the main bundle (#50109 )	2026-09-20 16:18:50 +10:00
Luke Parker	7fc3f68007	perf(desktop): boot the renderer alongside the main bundle (#50108 )	2026-09-20 16:15:58 +10:00
opencode-agent[bot]	cdcbb0047e	chore(core): refresh bundled models.dev snapshot	2026-09-20 05:38:29 +00:00
opencode-agent[bot]	a1956a7522	chore(core): refresh bundled models.dev snapshot	2026-09-20 04:42:05 +00:00
opencode-agent[bot]	55bc7fd403	chore(core): refresh bundled models.dev snapshot	2026-09-20 03:43:32 +00:00
opencode-agent[bot]	3049b1e684	chore(core): refresh bundled models.dev snapshot	2026-09-20 02:45:23 +00:00
opencode-agent[bot]	1f36a7aff8	chore(core): refresh bundled models.dev snapshot	2026-09-20 01:31:11 +00:00
Aiden Cline	eb0e26b974	feat(codemode): return live iterators from keys, values, and entries (#50061 )	2026-09-19 18:46:35 -05:00
opencode-agent[bot]	6f2b0e7833	chore(core): refresh bundled models.dev snapshot	2026-09-19 23:38:19 +00:00
opencode-agent[bot]	f153255942	chore(core): refresh bundled models.dev snapshot	2026-09-19 22:37:11 +00:00
opencode-agent[bot]	fef2fad76f	chore(core): refresh bundled models.dev snapshot	2026-09-19 22:15:20 +00:00
Aiden Cline	f30d06ea34	fix(core): pin the session to http after repeated websocket stream losses (#50031 )	2026-09-19 16:45:54 -05:00
Kit Langton	dfa44e94e8	fix(tui): use focused action token for question form border (#50037 )	2026-09-19 19:07:10 +00:00
Aiden Cline	b81e10a461	fix(core): re-read models.dev catalog after subscribing to Refreshed (#50012 )	2026-09-19 13:31:38 -05:00
Aiden Cline	65c93b69ed	fix(ai): never fail decoding on Responses error frames (#49402 )	2026-09-19 13:27:05 -05:00
Aiden Cline	b073b052d3	fix(ai): remove bounded websocket inbound queues (#50026 )	2026-09-19 13:26:37 -05:00