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

The first window now loads its document the moment Electron is ready: the same index.html without its module scripts, plus a sanitized copy of the shell captured at the end of the previous run. The renderer process, the stylesheet and the fonts are ready while the main bundle and the layers load, and the scripts are added when the window is adopted. The renderer asks for its RPC MessagePort instead of receiving one on did-finish-load, since that event fires before the scripts exist. The startup splash and its 300 ms fade are skipped when a snapshot is present; the snapshot is removed when the interface would have been revealed, and re-captured once idle and after route changes.
2026-09-19 07:16:26 +00:00 · 2026-09-19 13:49:56 +10:00
60 changed files with 582 additions and 535 deletions
@@ -205,6 +205,7 @@
      "dependencies": {
        "acorn": "8.15.0",
        "effect": "catalog:",
+        "typescript": "catalog:",
      },
      "devDependencies": {
        "@tsconfig/bun": "catalog:",
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-8mOzCscBAuogG4tm8CroqjTX5E5yzCvTobbhKvxQP0U=",
-    "aarch64-linux": "sha256-drrRSpzxC8bfaTXBpOyaN0QAyBVV7WJzm0NstJ+8sAE=",
-    "aarch64-darwin": "sha256-YY5A/zxLPONvgnI+DZlzcD2K5Q9PIw4F2YbDxKbT4UU=",
-    "x86_64-darwin": "sha256-/c/Ew4onA+9+l6GRKXz3zWq3QFESM7j5RyGLCWRPQFw="
+    "x86_64-linux": "sha256-TRfKunG6/UE8rQFyRkx/pX+pe7GT542IJWLEKcFFfAY=",
+    "aarch64-linux": "sha256-JxCYBQoHeJVuEMEe4Ef5f6UxxUCAuhPo96jqMT047Fc=",
+    "aarch64-darwin": "sha256-UEgjeQMivNC7JVsLEDlNbuqp9LJH84f9nHgLHTZ2zDI=",
+    "x86_64-darwin": "sha256-jEs/Oadjf2LVAinY0xyFna0V+NTwoCKXiXmQ83OchF8="
  }
 }
@@ -66,6 +66,7 @@ const inputDelta = (tool: PendingTool, text: string) =>
    name: tool.name,
    namespace: tool.namespace,
    text,
+    input: Option.getOrElse(parsePartialInput(tool.input), () => ({})),
  })

 const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
@@ -182,7 +182,7 @@ export const ToolInputDelta = Schema.Struct({
  name: Schema.String,
  namespace: Schema.optional(Schema.String),
  text: Schema.String,
-  /** Optional best-effort parse supplied by adapters; native routes emit raw text until the final tool call. */
+  /** Best-effort parse of all input fragments received through this delta. */
  input: Schema.optional(Schema.Unknown),
 }).annotate({ identifier: "LLM.Event.ToolInputDelta" })
 export type ToolInputDelta = Schema.Schema.Type<typeof ToolInputDelta>
@@ -1680,12 +1680,13 @@ describe("Anthropic Messages route", () => {
      expect(response.events).toEqual([
        { type: "step-start", index: 0 },
        { type: "tool-input-start", id: "call_1", name: "lookup" },
-        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"' },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"', input: {} },
        {
          type: "tool-input-delta",
          id: "call_1",
          name: "lookup",
          text: ':"weather"}',
+          input: { query: "weather" },
        },
        { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata: undefined },
        {
@@ -822,12 +822,13 @@ describe("Bedrock Converse route", () => {
      ])
      const events = response.events.filter((event) => event.type === "tool-input-delta")
      expect(events).toEqual([
-        { type: "tool-input-delta", id: "tool_1", name: "lookup", text: '{"query"' },
+        { type: "tool-input-delta", id: "tool_1", name: "lookup", text: '{"query"', input: {} },
        {
          type: "tool-input-delta",
          id: "tool_1",
          name: "lookup",
          text: ':"weather"}',
+          input: { query: "weather" },
        },
      ])
      expect(response.events.at(-1)).toMatchObject({
@@ -915,6 +916,7 @@ describe("Bedrock Converse route", () => {
          id: "tool_1",
          name: "lookup",
          text: '{"query":"weather"}',
+          input: { query: "weather" },
        },
      ])
    }),
@@ -413,12 +413,14 @@ describe("Mistral Chat", () => {
          id: "Ab12Cd34E",
          name: "lookup",
          text: '{"city":',
+          input: {},
        },
        {
          type: "tool-input-delta",
          id: "Ab12Cd34E",
          name: "lookup",
          text: '"Paris"}',
+          input: { city: "Paris" },
        },
        { type: "tool-input-end", id: "Ab12Cd34E", name: "lookup", providerMetadata: undefined },
        {
@@ -313,6 +313,7 @@ describe("Open Responses basic-item lifecycles", () => {
          id: "call_bc1eb4b42e70ee53",
          name: "get_weather",
          text: '{\n  "city": "Paris"\n}',
+          input: { city: "Paris" },
        },
        { type: "tool-input-end", id: "call_bc1eb4b42e70ee53", name: "get_weather", providerMetadata },
        {
@@ -1511,12 +1511,13 @@ describe("OpenAI Chat route", () => {
      expect(response.events).toEqual([
        { type: "step-start", index: 0 },
        { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata: undefined },
-        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"' },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"', input: {} },
        {
          type: "tool-input-delta",
          id: "call_1",
          name: "lookup",
          text: ':"weather"}',
+          input: { query: "weather" },
        },
        { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata: undefined },
        {
@@ -1567,6 +1568,7 @@ describe("OpenAI Chat route", () => {
          id: "call_1",
          name: "lookup",
          text: '{"query":"weather"',
+          input: { query: "weather" },
        },
        {
          type: "step-finish",
@@ -1622,6 +1624,7 @@ describe("OpenAI Chat route", () => {
          id: "call_1",
          name: "lookup",
          text: '{"query":"weather"}',
+          input: { query: "weather" },
        },
        {
          type: "step-finish",
@@ -1687,6 +1690,7 @@ describe("OpenAI Chat route", () => {
          id: "call_1",
          name: "lookup",
          text: '{"query":"weather"',
+          input: { query: "weather" },
        },
      ])
    }),
@@ -1776,12 +1780,13 @@ describe("OpenAI Chat route", () => {
      expect(response.events).toEqual([
        { type: "step-start", index: 0 },
        { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata: undefined },
-        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"' },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: '{"query"', input: {} },
        {
          type: "tool-input-delta",
          id: "call_1",
          name: "lookup",
          text: ':"weather"}',
+          input: { query: "weather" },
        },
        { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata: undefined },
        {
@@ -4038,12 +4038,14 @@ describe("OpenAI Responses route", () => {
          id: "call_1",
          name: "lookup",
          text: '{"query"',
+          input: {},
        },
        {
          type: "tool-input-delta",
          id: "call_1",
          name: "lookup",
          text: ':"weather"}',
+          input: { query: "weather" },
        },
        {
          type: "tool-input-end",
@@ -4115,8 +4117,8 @@ describe("OpenAI Responses route", () => {
      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))

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

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

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

+  test("defaults partial input to an empty object when the accumulated value cannot be parsed", () => {
+    const result = ToolStream.appendOrStart(
+      ADAPTER,
+      ToolStream.empty<number>(),
+      0,
+      { id: "call_1", name: "lookup", text: "x" },
+      "missing tool",
+    )
+    if (ToolStream.isError(result)) throw result
+
+    expect(result.events).toEqual([
+      { type: "tool-input-start", id: "call_1", name: "lookup" },
+      { type: "tool-input-delta", id: "call_1", name: "lookup", text: "x", input: {} },
+    ])
+  })
+
  it.effect("keeps accumulated identity when later deltas contain empty strings", () =>
    Effect.gen(function* () {
      const first = ToolStream.appendOrStart(
@@ -456,10 +456,6 @@ export type V2EventServerConnected = {
  data: {}
 }

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

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

+export type ModelVariant = {
+  id: string
+  settings?: ProviderSettings
+  headers?: { [x: string]: string }
+  body?: { [x: string]: any }
+}
+
 export type ProviderInfo = {
  id: string
  canonical?: string
@@ -1902,7 +1898,7 @@ export type ModelInfo = {
  name: string
  compatibility?: ModelCompatibility
  package?: string
-  settings?: ModelSettings
+  settings?: ProviderSettings
  headers?: { [x: string]: string }
  body?: { [x: string]: any }
  capabilities: ModelCapabilities
@@ -2111,13 +2107,13 @@ export type ConfigEntry =
                name?: string
                compatibility?: ModelCompatibility
                package?: string
-                settings?: ConfigModelSettings
+                settings?: ConfigProviderSettings
                headers?: { [x: string]: string }
                body?: { [x: string]: JsonValue }
                capabilities?: ModelCapabilities
                variants?: Array<{
                  id: string
-                  settings?: ConfigModelSettings
+                  settings?: ConfigProviderSettings
                  headers?: { [x: string]: string }
                  body?: { [x: string]: JsonValue }
                }>
@@ -15,7 +15,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 ## Source and execution model

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

 ## Values and literals

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-function responsesWebSocketCapable(provider: Provider.Info) {
-  if (provider.package !== "@opencode/ai/providers/azure/responses") return false
-  const settings = provider.settings
+function responsesWebSocketCapable(provider: Provider.Info, model: Model.Info) {
+  if ((model.package ?? provider.package) !== "@opencode/ai/providers/azure/responses") return false
+  const settings = Provider.mergeOverlay(provider.settings, model.settings)
  if (settings?.useDeploymentBasedUrls === true) return false
  if (settings?.apiVersion !== undefined && settings.apiVersion !== "v1") return false
  if (typeof settings?.baseURL !== "string") return true
@@ -254,13 +254,10 @@ export const OpenAIPlugin = define({
    yield* ctx.provider.transform((providers) => {
      const item = providers.get(Provider.ID.openai)
      if (!item) return
-      const account = chatgpt?.metadata?.accountID
+      if (!chatgpt) return
+      const account = chatgpt.metadata?.accountID
      providers.update(item.provider.id, (provider) => {
-        provider.settings = Provider.mergeOverlay(provider.settings, {
-          transport: provider.settings?.transport ?? "websocket",
-          ...(chatgpt ? { baseURL: codexBaseURL } : {}),
-        })
-        if (!chatgpt) return
+        provider.settings = Provider.mergeOverlay(provider.settings, { baseURL: codexBaseURL })
        provider.headers = Provider.mergeHeaders(provider.headers, {
          originator: "opencode",
          "x-codex-beta-features": "remote_compaction_v2",
@@ -273,6 +270,9 @@ export const OpenAIPlugin = define({
        // ChatGPT-plan tokens only authorize codex-eligible models, and the
        // subscription covers usage, so hide the rest and zero the cost.
        models.update(model.providerID, model.id, (draft) => {
+          draft.settings = Provider.mergeOverlay(draft.settings, {
+            transport: models.provider.get(model.providerID)?.provider.settings?.transport ?? "websocket",
+          })
          if (!chatgpt) return
          if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(draft.body?.reasoning)) {
            draft.enabled = false
@@ -95,13 +95,14 @@ export const XAIPlugin = define({
      editor.method.update(device(ctx.app))
      editor.method.update({ integrationID: "xai", method: { type: "key", label: "Manually enter API Key" } })
    })
-    yield* ctx.provider.transform((providers) => {
-      if (!providers.get(providerID)) return
-      providers.update(providerID, (provider) => {
-        provider.settings = Provider.mergeOverlay(provider.settings, {
-          transport: provider.settings?.transport ?? "websocket",
+    yield* ctx.model.transform((models) => {
+      for (const model of models.list(providerID)) {
+        models.update(providerID, model.id, (draft) => {
+          draft.settings = Provider.mergeOverlay(draft.settings, {
+            transport: models.provider.get(providerID)?.provider.settings?.transport ?? "websocket",
+          })
        })
-      })
+      }
    })
  }),
 })
@@ -134,16 +134,11 @@ export const loadPackage = Effect.fn("Provider.loadPackage")(function* (input: s

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

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

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

 const it = testEffect(AISDK.locationLayer)

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

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

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

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

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

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

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

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

        yield* addPlugin()

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

      yield* addPlugin()

-      const provider = yield* providers.get(providerID)
      const model = yield* models.get(providerID, Model.ID.make("grok-4.6"))
-      expect(provider?.settings?.transport).toBe("websocket")
-      expect(model?.settings?.transport).toBeUndefined()
+      expect(model?.settings?.transport).toBe("websocket")
    }),
  )
 })
@@ -42,19 +42,4 @@ describe("Provider", () => {
      reasoningEffort: "high",
    })
  })
-
-  test("inherits shared and loose settings without provider-only policies", () => {
-    expect(
-      Provider.modelSettings({
-        timeout: 60_000,
-        chunkTimeout: 30_000,
-        transport: "websocket",
-        compaction: { type: "native" },
-        reasoningEffort: "high",
-      }),
-    ).toEqual({
-      compaction: { type: "native" },
-      reasoningEffort: "high",
-    })
-  })
 })
@@ -3,7 +3,7 @@
 //
 //   bun run bench:startup -- [--exe <path>] [--compare <path>] [--runs 5] [--warmup 1] [--service warm|cold]
 //                            [--fresh] [--offline] [--seed <userData dir>] [--profile-main] [--profile-renderer]
-//                            [--trace] [--out <dir>] [--home <dir>] [--window-at x,y]
+//                            [--trace] [--out <dir>] [--home <dir>]
 //
 // The app runs in an isolated home directory (its own %APPDATA%, XDG dirs, OpenCode DB, config and
 // service registration) with the developer's OPENCODE_* / OTEL_* environment stripped, so it never
@@ -21,15 +21,7 @@
 // main-process CPU profile from the first statement (via --inspect-brk) on the first run,
 // `--profile-renderer` records the renderer main thread from the moment its debug target appears,
 // and `--trace` records Chromium's startup trace on the last run. Raw samples are written as JSON.
-//
-// What is on screen is sampled from the screen itself (Windows): a helper pins the window topmost
-// without activating it the moment it exists, then records when the window's pixels first differ
-// from the background colour (`screenPainted`) and when they stop changing (`screenSettled`).
-// Renderer paint timing alone is not enough: Chromium stops painting an occluded window, and a
-// splash or a fade reads as "painted" long before the interface is on screen. `--window-at` puts
-// the window somewhere the developer's foreground window does not cover. BENCH_SCREEN_DUMP=<dir>
-// also saves every sample as PNG, BENCH_EXTRA_ARGS passes extra Chromium switches to the app.
-import { execFileSync, spawn } from "node:child_process"
+import { spawn } from "node:child_process"
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs"
 import { createServer } from "node:net"
 import { tmpdir } from "node:os"
@@ -53,9 +45,6 @@ const args = parseArgs({
    "profile-renderer": { type: "boolean", default: false },
    trace: { type: "boolean", default: false },
    "settle-ms": { type: "string", default: "1500" },
-    // Restore the bench window at "x,y" (and treat that display as trusted), for example on a display
-    // that the developer's foreground window does not cover; Chromium stops painting an occluded window.
-    "window-at": { type: "string" },
  },
  allowPositionals: true,
 })
@@ -123,12 +112,10 @@ const probe = `(() => ({
  origin: performance.timeOrigin,
  firstPaint: performance.getEntriesByType('paint').find((e) => e.name === 'first-paint')?.startTime,
  domInteractive: performance.getEntriesByType('navigation')[0]?.domInteractive,
-  prepaint: !!document.getElementById('oc-prepaint'),
-  visible: document.visibilityState === 'visible',
-  shell: !!document.querySelector('#root [data-titlebar-tab-link], #root [data-action="vertical-tabs-home"]'),
-  editor: !!document.querySelector('#root [data-component="composer-editor"][contenteditable="true"]'),
-  rows: document.querySelectorAll('#root [data-timeline-row]').length,
-  home: !!document.querySelector('#root [data-action="home-new-session"], #root [data-action="home-add-project-row"]'),
+  shell: !!document.querySelector('[data-titlebar-tab-link], [data-action="vertical-tabs-home"]'),
+  editor: !!document.querySelector('[data-component="composer-editor"][contenteditable="true"]'),
+  rows: document.querySelectorAll('[data-timeline-row]').length,
+  home: !!document.querySelector('[data-action="home-new-session"], [data-action="home-add-project-row"]'),
  url: location.pathname + location.search,
 }))()`
 // Main-process bootstrap timing, read after the run: when the process was created, when Node
@@ -250,8 +237,6 @@ type Probe = {
  origin: number
  firstPaint?: number
  domInteractive?: number
-  prepaint: boolean
-  visible: boolean
  shell: boolean
  editor: boolean
  rows: number
@@ -288,7 +273,6 @@ async function launch(build: { label: string; exe: string }, run: number): Promi
  const trace = args.values.trace && run === runs
  const tracePath = join(outDir, `startup-trace-${Date.now()}.json`)
  const launchArgs = [
-    ...(process.env.BENCH_EXTRA_ARGS?.split(" ").filter(Boolean) ?? []),
    `--remote-debugging-port=${cdpPort}`,
    profile ? `--inspect-brk=${inspectPort}` : `--inspect=${inspectPort}`,
    ...(trace
@@ -300,12 +284,10 @@ async function launch(build: { label: string; exe: string }, run: number): Promi
        ]
      : []),
  ]
-  const raiser = await windowRaiser()
  const spawnAt = Date.now()
  const child = spawn(build.exe, launchArgs, { env, detached: true, stdio: "ignore" })
  child.unref()
  appPid = child.pid
-  raiser.raise(child.pid!)

  let mainProfile: Promise<unknown> | undefined
  if (profile) mainProfile = profileMain(spawnAt)
@@ -327,7 +309,6 @@ async function launch(build: { label: string; exe: string }, run: number): Promi
  // when the shell is up and the main thread has spent under 10 % of any 500 ms window in tasks for `settleMs`.
  const seen: Record<string, number> = {}
  let last: Probe | undefined
-  let prepaintSeen = false
  let quietSince: number | undefined
  let taskMs = 0
  let scriptMs = 0
@@ -337,9 +318,6 @@ async function launch(build: { label: string; exe: string }, run: number): Promi
    const result = await cdp.send("Runtime.evaluate", { expression: probe, returnByValue: true })
    last = result.result?.result?.value as Probe | undefined
    const t = Date.now() - spawnAt
-    if (last?.prepaint) prepaintSeen = true
-    // Chromium marks a window it considers occluded hidden and the renderer stops painting.
-    if (last?.visible && !seen.documentVisible) seen.documentVisible = t
    if (last?.shell && !seen.shellVisible) seen.shellVisible = t
    if (last?.editor && !seen.composerEditable) seen.composerEditable = t
    if (last?.rows && !seen.timelineRows) seen.timelineRows = t
@@ -378,7 +356,6 @@ async function launch(build: { label: string; exe: string }, run: number): Promi
  const timelineResult = await cdp.send("Runtime.evaluate", { expression: rendererTimeline, returnByValue: true })
  cdp.close()
  const processes = appPid ? await processTree(appPid) : []
-  const screenChanges = await raiser.screen()
  const boot = profile ? undefined : await mainBootTiming()
  await sleep(300)
  // Chromium writes the startup trace when --trace-startup-duration elapses; keep the app alive until then.
@@ -408,16 +385,7 @@ async function launch(build: { label: string; exe: string }, run: number): Promi
      domInteractive:
        last?.domInteractive !== undefined && origin !== undefined ? Math.round(origin + last.domInteractive) : undefined,
      firstPaint: last?.firstPaint !== undefined && origin !== undefined ? Math.round(origin + last.firstPaint) : undefined,
-      // With a shell snapshot in the early document, first paint is the snapshot, not the app.
-      prepaintVisible:
-        prepaintSeen && last?.firstPaint !== undefined && origin !== undefined
-          ? Math.round(origin + last.firstPaint)
-          : undefined,
      ...seen,
-      // First sampled screen change inside the window: the ground truth for "the user sees something".
-      screenPainted: screenChanges.changed[0],
-      // When the sampled window content stopped changing: the interface, not a splash, is on screen.
-      screenSettled: screenChanges.settled,
      rendererIdle: rendererIdleMs,
    },
    final: { url: last?.url, timelineRows: last?.rows },
@@ -483,22 +451,6 @@ function prepareHome() {
    })
  }
  mkdirSync(paths.logs, { recursive: true })
-  const at = args.values["window-at"]?.split(",").map(Number)
-  if (at?.length === 2 && existsSync(userData)) {
-    for (const file of readdirSync(userData).filter((name) => /^window-state-.*\.json$/.test(name))) {
-      const state = JSON.parse(readFileSync(join(userData, file), "utf8"))
-      const bounds = displayAt(at[0], at[1])
-      writeFileSync(join(userData, file), JSON.stringify({ ...state, x: at[0], y: at[1], isMaximized: false, isFullScreen: false, displayBounds: bounds }))
-    }
-  }
-}
-
-function displayAt(x: number, y: number) {
-  if (process.platform !== "win32") return undefined
-  const out = execFileSync("pwsh", ["-NoProfile", "-NonInteractive", "-Command", "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::AllScreens | ForEach-Object { \"$($_.Bounds.X),$($_.Bounds.Y),$($_.Bounds.Width),$($_.Bounds.Height)\" }"], { encoding: "utf8" })
-  const displays = out.trim().split(/\r?\n/).map((line) => line.split(",").map(Number))
-  const hit = displays.find(([dx, dy, dw, dh]) => x >= dx && y >= dy && x < dx + dw && y < dy + dh)
-  return hit ? { x: hit[0], y: hit[1], width: hit[2], height: hit[3] } : undefined
 }

 async function freePort() {
@@ -613,86 +565,6 @@ function mainLog() {
 }

 // Working set of every process in the launched app's tree once it is idle.
-// Windows places a window launched from a background process behind the foreground one, and
-// Chromium then marks it occluded and the renderer stops painting, so paint timings would depend on
-// what else is on screen. A helper started before the app polls for its main window and pins it
-// topmost without activating it, so the user keeps their focus and the bench window is visible.
-async function windowRaiser(): Promise<{ raise: (pid: number) => void; screen: () => Promise<number[]> }> {
-  if (process.platform !== "win32") return { raise: () => {}, screen: async () => [] }
-  const script = join(outDir, "raise-window.ps1")
-  writeFileSync(
-    script,
-    [
-      `Add-Type -AssemblyName System.Drawing`,
-      `Add-Type -Namespace Bench -Name User32 -MemberDefinition '[DllImport("user32.dll")] public static extern bool SetWindowPos(IntPtr h, IntPtr a, int x, int y, int w, int z, uint f); [StructLayout(LayoutKind.Sequential)] public struct RECT { public int L; public int T; public int R; public int B; } [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr h, out RECT r);'`,
-      `[Console]::Out.WriteLine("ready")`,
-      `$target = [int][Console]::In.ReadLine()`,
-      `$clock = [Diagnostics.Stopwatch]::StartNew()`,
-      `$h = 0`,
-      `for ($i = 0; $i -lt 600; $i++) {`,
-      `  $h = (Get-Process -Id $target -ErrorAction SilentlyContinue).MainWindowHandle`,
-      `  if ($h -and $h -ne 0) { [Bench.User32]::SetWindowPos($h, [IntPtr](-1), 0, 0, 0, 0, 0x13) | Out-Null; [Console]::Out.WriteLine("raised " + $clock.ElapsedMilliseconds); break }`,
-      `  Start-Sleep -Milliseconds 10`,
-      `}`,
-      `if (-not $h -or $h -eq 0) { exit }`,
-      // Sample a 16x16 grid of pixels inside the window: cheap, and enough to tell the background
-      // colour, a splash and the interface apart.
-      `$r = New-Object Bench.User32+RECT`,
-      `while ($clock.ElapsedMilliseconds -lt 3000) {`,
-      `  [Bench.User32]::GetWindowRect($h, [ref]$r) | Out-Null`,
-      `  $w = $r.R - $r.L; $ht = $r.B - $r.T`,
-      `  if ($w -le 48 -or $ht -le 48) { Start-Sleep -Milliseconds 30; continue }`,
-      `  $t = $clock.ElapsedMilliseconds`,
-      `  $bmp = New-Object System.Drawing.Bitmap $w, $ht`,
-      `  $g = [System.Drawing.Graphics]::FromImage($bmp)`,
-      `  try { $g.CopyFromScreen($r.L, $r.T, 0, 0, $bmp.Size) } catch { $g.Dispose(); $bmp.Dispose(); Start-Sleep -Milliseconds 30; continue }`,
-      `  $sum = 0`,
-      `  for ($i = 1; $i -le 16; $i++) { for ($j = 1; $j -le 16; $j++) { $p = $bmp.GetPixel([int]($w * $j / 17), [int]($ht * $i / 17)); $sum += [int]$p.R + [int]$p.G + [int]$p.B } }`,
-      `  [Console]::Out.WriteLine("screen " + $t + " " + $sum)`,
-      `  if ($env:BENCH_SCREEN_DUMP) { $bmp.Save((Join-Path $env:BENCH_SCREEN_DUMP ("screen-" + $t.ToString().PadLeft(4, "0") + ".png"))) }`,
-      `  $g.Dispose(); $bmp.Dispose()`,
-      `  Start-Sleep -Milliseconds 30`,
-      `}`,
-    ].join("\n"),
-  )
-  const helper = spawn("pwsh", ["-NoProfile", "-NonInteractive", "-File", script], { stdio: ["pipe", "pipe", "pipe"] })
-  const lines: string[] = []
-  let buffer = ""
-  await new Promise<void>((resolve) => {
-    helper.stdout!.on("data", (chunk: Buffer) => {
-      buffer += chunk.toString()
-      const parts = buffer.split(/\r?\n/)
-      buffer = parts.pop() ?? ""
-      for (const line of parts) {
-        if (line === "ready") resolve()
-        else lines.push(line)
-      }
-    })
-    helper.stderr!.on("data", (chunk: Buffer) => console.error(`raise-window: ${chunk.toString().trim()}`))
-    helper.on("exit", () => resolve())
-  })
-  const exited = new Promise<void>((resolve) => helper.on("exit", () => resolve()))
-  return {
-    raise: (pid) => helper.stdin!.write(`${pid}\n`),
-    // Resolves with the times (ms since the pid was sent, ~spawn) at which the sampled screen
-    // content differed from the first sample, i.e. when something other than the background colour
-    // was on screen.
-    screen: async () => {
-      await exited
-      const samples = lines
-        .filter((line) => line.startsWith("screen "))
-        .map((line) => line.split(" ").slice(1).map(Number) as [number, number])
-      if (process.env.BENCH_DEBUG) console.log(lines.filter((line) => line.startsWith("raised")).join(" "), `${samples.length} screen samples`)
-      const first = samples[0]?.[1]
-      const last = samples.at(-1)?.[1]
-      const differs = (a: number, b: number) => Math.abs(a - b) > 16 * 16 * 12
-      const changed = samples.filter(([, sum]) => differs(sum, first)).map(([t]) => t)
-      // The last sample that still differed from the final content, i.e. when the window stopped changing.
-      const settledIndex = samples.findLastIndex(([, sum]) => last !== undefined && differs(sum, last))
-      return { changed, settled: settledIndex >= 0 ? samples[settledIndex + 1]?.[0] : samples[0]?.[0] }
-    },
-  }
-}
 async function processTree(root: number) {
  const script =
    process.platform === "win32"
@@ -2,7 +2,14 @@ import { BrowserWindow } from "electron"
 import { Effect } from "effect"
 import { WindowRpcs } from "../../shared/ipc-rpc"
 import { IpcPortHandoff } from "../ipc-transport"
-import { getPinchZoomEnabled, setPinchZoomEnabled, setTitlebar, setWindowThemeReady, updateTitlebar } from "../windows"
+import {
+  getPinchZoomEnabled,
+  saveWindowPrepaint,
+  setPinchZoomEnabled,
+  setTitlebar,
+  setWindowThemeReady,
+  updateTitlebar,
+} from "../windows"
 import { sender } from "./context"

 export const windowHandlers = WindowRpcs.toLayer(
@@ -38,6 +45,11 @@ export const windowHandlers = WindowRpcs.toLayer(
          const win = BrowserWindow.fromWebContents(sender(handoff, context))
          if (win) setTitlebar(win, theme)
        }),
+      WindowSavePrepaint: ({ html }, context) =>
+        Effect.promise(() => {
+          const win = BrowserWindow.fromWebContents(sender(handoff, context))
+          return win ? saveWindowPrepaint(win, html) : Promise.resolve()
+        }),
    })
  }),
 )
@@ -1,10 +1,10 @@
 export * as Ipc from "./ipc"

-import { app, BrowserWindow, MessageChannelMain } from "electron"
+import { app, BrowserWindow, ipcMain, MessageChannelMain } from "electron"
 import { Effect, Layer } from "effect"
 import { RpcServer } from "effect/unstable/rpc"
 import { DesktopRpcs } from "../shared/ipc-rpc"
-import { DragCancelEvent, IpcTransportPort } from "../shared/ipc-transport"
+import { DragCancelEvent, IpcTransportPort, IpcTransportPortRequest } from "../shared/ipc-transport"
 import { DesktopFiles, openExternalURL } from "./files"
 import { appHandlers } from "./ipc-handlers/app"
 import { eventHandlers } from "./ipc-handlers/events"
@@ -23,6 +23,7 @@ import { createMenu, sendMenuCommand } from "./native/menu"
 import { DesktopCli } from "./service/desktop-cli"
 import { Updater } from "./updater"
 import { getLastFocusedWindow } from "./windows"
+import { isRendererUrl } from "./windows/protocol"
 import { Wsl } from "./wsl/start"

 const services = Layer.mergeAll(DesktopFiles.layer, Wsl.layer, Ssh.layer)
@@ -65,18 +66,27 @@ export const registerIpcHandlers = Effect.gen(function* () {
      if (input.type !== "keyDown" || input.key !== "Escape") return
      win.webContents.send(DragCancelEvent)
    })
-    win.webContents.on("did-finish-load", () => {
-      if (win.isDestroyed() || win.webContents.isDestroyed()) return
-      const channel = new MessageChannelMain()
-      handoff.bind(win.webContents, channel.port1)
-      win.webContents.postMessage(IpcTransportPort, null, [channel.port2])
-    })
+  }
+  // Each renderer document asks for its own port once its client is listening; see ipc-client.ts.
+  const handPort = (event: Electron.IpcMainEvent) => {
+    const contents = event.sender
+    if (contents.isDestroyed() || !isRendererUrl(contents.getURL())) return
+    const channel = new MessageChannelMain()
+    handoff.bind(contents, channel.port1)
+    contents.postMessage(IpcTransportPort, null, [channel.port2])
  }
  yield* Effect.sync(() => {
    app.on("browser-window-created", wire)
    BrowserWindow.getAllWindows().forEach((win) => wire({} as Electron.Event, win))
+    ipcMain.on(IpcTransportPortRequest, handPort)
  })
-  yield* Effect.addFinalizer(() => Effect.sync(() => app.off("browser-window-created", wire)))
+  yield* Effect.addFinalizer(
+    () =>
+      Effect.sync(() => {
+        app.off("browser-window-created", wire)
+        ipcMain.off(IpcTransportPortRequest, handPort)
+      }),
+  )
  return {
    installMenu: () => createMenu(menu),
  }
@@ -99,7 +99,9 @@ export function setZoomFactor(win: BrowserWindow, factor: number) {

 export function wireZoom(win: BrowserWindow) {
  pinchZoomEnabled.set(win, getPinchZoomEnabled())
-  win.webContents.setZoomFactor(1)
+  // Setting the factor forces a visual-properties round trip with the renderer, so leave it alone
+  // when it is already 1: the first window has a document on screen by now.
+  if (win.webContents.getZoomFactor() !== 1) win.webContents.setZoomFactor(1)
  win.webContents.on("zoom-changed", (event, direction) => {
    event.preventDefault()
    if (pinchZoomEnabled.get(win)) {
@@ -6,9 +6,11 @@ import { windowIDArgument } from "../../shared/window-bootstrap"
 import { WINDOW_IDS_KEY } from "../storage/keys"
 import { getStore } from "../storage/store"
 import { storedBackgroundColor, titlebarOverlay } from "./defaults"
+import { rendererHost, rendererProtocol } from "./scheme"
+import { earlyQuery, serveRenderer } from "./serve"
 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; loaded: boolean }

 let pending: EarlyWindow | undefined

@@ -56,7 +58,16 @@ export function createEarlyWindow() {
    pending = undefined
    app.quit()
  })
-  pending = { id, win, state, shownAt: Date.now() }
+  // In production the window starts its document now - the same index.html without its scripts,
+  // carrying the shell snapshot from the previous run - so the renderer process and the stylesheet
+  // are ready, and the user sees their UI, while the bundle and the layers load. The scripts are
+  // added when restoreWindows() adopts the window. Development keeps loading from the dev server.
+  const loaded = !process.env.ELECTRON_RENDERER_URL
+  if (loaded) {
+    serveRenderer(path.join(root, "../renderer"))
+    void win.loadURL(`${rendererProtocol}://${rendererHost}/index.html?${earlyQuery}=${encodeURIComponent(id)}`)
+  }
+  pending = { id, win, state, shownAt: Date.now(), loaded }
 }

 export function takeEarlyWindow() {
@@ -22,6 +22,8 @@ import {
  wireZoom,
 } from "./appearance"
 import { loadWindow, registerRendererProtocol } from "./protocol"
+import { removePrepaint, writePrepaint } from "./prepaint"
+import { releaseRenderer } from "./serve"
 import { createWindowRegistry } from "./registry"
 import { makeWindowRecovery } from "./recovery"
 import { takeEarlyWindow, type EarlyWindow } from "./early"
@@ -29,6 +31,7 @@ import { manageWindowState, readWindowState, resolveWindowState, windowStateFile
 import { allowRendererPermissions, wireNavigationPolicy, wireRendererHeaders } from "./security"

 const themeReady = new WeakMap<BrowserWindow, () => void>()
+const windowIDs = new WeakMap<BrowserWindow, string>()
 const displays = {
  all: () => screen.getAllDisplays().map((display) => display.bounds),
  primary: () => screen.getPrimaryDisplay().bounds,
@@ -80,6 +83,12 @@ export function setWindowThemeReady(win: BrowserWindow) {
  themeReady.get(win)?.()
 }

+export function saveWindowPrepaint(win: BrowserWindow, html: string) {
+  const id = windowIDs.get(win)
+  if (!id) return Promise.resolve()
+  return writePrepaint(id, html)
+}
+
 export const makeMainWindows = Effect.fn("Window.make")(function* () {
  const fs = yield* FileSystem.FileSystem
  const path = yield* Path.Path
@@ -126,7 +135,13 @@ export const makeMainWindows = Effect.fn("Window.make")(function* () {
    if (!early) manageWindowState(win, stateFile, state, displays)
    register(win, id)
    wireFullscreen(win)
-    loadWindow(win, "index.html")
+    if (early?.loaded) {
+      runFork(
+        Effect.tryPromise(() => releaseRenderer(win, paths.rendererRoot)).pipe(
+          Effect.catch((error) => scoped("window", Effect.logError("failed to release early renderer", { id, error }))),
+        ),
+      )
+    } else loadWindow(win, "index.html")
    wireZoom(win)
    let contentReady = false
    let appliedTheme = false
@@ -163,6 +178,7 @@ export const makeMainWindows = Effect.fn("Window.make")(function* () {

  const register = (win: BrowserWindow, id: string) => {
    registry.register(id, win)
+    windowIDs.set(win, id)
    win.on("focus", () => registry.focused(id))
    // Windows emits session-end, but not before-quit, during shutdown and logoff.
    win.on("session-end", () => registry.setQuitting())
@@ -172,6 +188,7 @@ export const makeMainWindows = Effect.fn("Window.make")(function* () {
        Effect.gen(function* () {
          yield* Effect.try(() => storage.state.clear(windowDataFile(id)))
          yield* fs.remove(path.join(app.getPath("userData"), windowStateFile(id)), { force: true })
+          yield* Effect.promise(() => removePrepaint(id))
        }).pipe(
          Effect.catch((error) => scoped("window", Effect.logError("failed to clean window state", { id, error }))),
        ),
@@ -0,0 +1,27 @@
+import { mkdir, rename, rm, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { app } from "electron"
+
+// The shell snapshot a window shows before its renderer has booted. It is a file next to the
+// window-state JSON rather than a row in the desktop database because the entry module serves it
+// before the storage layers exist; a snapshot from another app version is ignored, since its class
+// names may no longer match the bundled stylesheet.
+
+export function prepaintFile(id: string) {
+  return `prepaint-${id.replace(/[^a-zA-Z0-9._-]/g, "-")}.html`
+}
+
+export function prepaintMarker(version: string) {
+  return `<!-- opencode ${version} -->`
+}
+
+export async function writePrepaint(id: string, html: string) {
+  const file = path.join(app.getPath("userData"), prepaintFile(id))
+  await mkdir(path.dirname(file), { recursive: true })
+  await writeFile(`${file}.tmp`, `${prepaintMarker(app.getVersion())}\n${html}`)
+  await rename(`${file}.tmp`, file)
+}
+
+export function removePrepaint(id: string) {
+  return rm(path.join(app.getPath("userData"), prepaintFile(id)), { force: true })
+}
@@ -1,54 +1,19 @@
-import { net, protocol } from "electron"
 import type { BrowserWindow } from "electron"
-import { pathToFileURL } from "node:url"
-import { Effect, Path } from "effect"
+import { Effect } from "effect"
 import { scoped } from "../native/logging"
 import { DesktopPaths } from "../paths"
-import { documentPolicyHeader, jsCallStacksDocumentPolicy } from "./headers"
 import { rendererHost, rendererProtocol } from "./scheme"
+import { serveRenderer, setRendererProtocolLogger } from "./serve"

+// The entry module normally registers the handler before the bundle loads; this only wires its
+// logging, and registers it when the entry module did not (development, or a window created later).
 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>())
-  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 })
-    }
-
-    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 })
-    }
-  })
+  setRendererProtocolLogger((level, message, data) =>
+    runFork(scoped("protocol", level === "error" ? Effect.logError(message, data) : Effect.logWarning(message, data))),
+  )
+  serveRenderer(paths.rendererRoot)
 })

 export function loadWindow(win: BrowserWindow, html: string) {
@@ -68,11 +33,4 @@ export function isRendererUrl(value?: string, html = false) {
  const devUrl = process.env.ELECTRON_RENDERER_URL
  if (!devUrl || !URL.canParse(devUrl)) return false
  return url.origin === new URL(devUrl).origin
-}
-
-function addDocumentPolicy(response: Response, file: string) {
-  if (!file.toLowerCase().endsWith(".html")) return response
-  const headers = new Headers(response.headers)
-  headers.set(documentPolicyHeader, jsCallStacksDocumentPolicy)
-  return new Response(response.body, { status: response.status, statusText: response.statusText, headers })
-}
+}
@@ -0,0 +1,114 @@
+import { readFile } from "node:fs/promises"
+import path from "node:path"
+import { pathToFileURL } from "node:url"
+import { app, net, protocol } from "electron"
+import type { BrowserWindow } from "electron"
+import { documentPolicyHeader, jsCallStacksDocumentPolicy } from "./headers"
+import { prepaintFile, prepaintMarker } from "./prepaint"
+import { rendererHost, rendererProtocol } from "./scheme"
+
+// Serves the renderer bundle over oc://renderer. This module has no Effect dependency because the
+// entry module registers it right after Electron is ready, before the main bundle has loaded, so
+// the first window can start its document while the bundle and the layers evaluate.
+
+export const earlyQuery = "early"
+
+type Log = (level: "warning" | "error", message: string, data: Record<string, unknown>) => void
+let log: Log = () => {}
+
+export function setRendererProtocolLogger(logger: Log) {
+  log = logger
+}
+
+export function serveRenderer(rendererRoot: string) {
+  if (protocol.isProtocolHandled(rendererProtocol)) return
+  protocol.handle(rendererProtocol, async (request) => {
+    const url = new URL(request.url)
+    if (url.host !== rendererHost) {
+      log("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)) {
+      log("warning", "rejected path", { url: request.url, file })
+      return new Response("Not found", { status: 404 })
+    }
+
+    const early = url.pathname === "/index.html" ? url.searchParams.get(earlyQuery) : null
+    if (early !== null) return earlyDocument(file, early)
+
+    try {
+      const range = request.headers.get("range")
+      const response = await net.fetch(pathToFileURL(file).toString(), { headers: range ? { range } : undefined })
+      if (response.status >= 400) {
+        log("error", "fetch failed", {
+          url: request.url,
+          file,
+          status: response.status,
+          statusText: response.statusText,
+        })
+      }
+      return addDocumentPolicy(response, file)
+    } catch (error) {
+      log("error", "fetch error", { url: request.url, file, error })
+      return new Response("Not found", { status: 404 })
+    }
+  })
+}
+
+// The early window loads index.html?early=<window id>: the same document without its module
+// scripts, plus the shell snapshot the window captured last time, so the user sees their own UI
+// while the main process is still loading. releaseRenderer() adds the scripts back once the window
+// has been adopted.
+async function earlyDocument(file: string, id: string) {
+  const [html, prepaint] = await Promise.all([
+    readFile(file, "utf8"),
+    readFile(path.join(app.getPath("userData"), prepaintFile(id)), "utf8").catch(() => undefined),
+  ])
+  const body = prepaint?.startsWith(prepaintMarker(app.getVersion()))
+    ? `<div id="oc-prepaint" inert aria-hidden="true" style="position:fixed;inset:0;z-index:100;pointer-events:none;display:flex;flex-direction:column;background-color:var(--background-base)">${prepaint.slice(prepaint.indexOf("\n") + 1)}</div></body>`
+    : "</body>"
+  const text = html.replace(moduleScript, "").replace("</body>", body)
+  return new Response(text, {
+    headers: {
+      "content-type": "text/html; charset=utf-8",
+      "cache-control": "no-store",
+      [documentPolicyHeader]: jsCallStacksDocumentPolicy,
+    },
+  })
+}
+
+const moduleScript = /<script type="module"[^>]*><\/script>\s*/g
+
+export async function releaseRenderer(win: BrowserWindow, rendererRoot: string) {
+  const html = await readFile(path.join(rendererRoot, "index.html"), "utf8")
+  const srcs = [...html.matchAll(moduleScript)].flatMap((match) => {
+    const src = /\bsrc="([^"]+)"/.exec(match[0])
+    return src ? [src[1]] : []
+  })
+  if (win.isDestroyed()) return
+  // async = false keeps the runtime chunk ahead of the entry, as the static tags did. Dropping the
+  // query afterwards makes a reload load the full document.
+  await win.webContents.executeJavaScript(
+    `(() => {
+      for (const src of ${JSON.stringify(srcs)}) {
+        const script = document.createElement("script")
+        script.type = "module"
+        script.async = false
+        script.crossOrigin = ""
+        script.src = src
+        document.head.appendChild(script)
+      }
+      history.replaceState(history.state, "", "/index.html")
+    })()`,
+  )
+}
+
+function addDocumentPolicy(response: Response, file: string) {
+  if (!file.toLowerCase().endsWith(".html")) return response
+  const headers = new Headers(response.headers)
+  headers.set(documentPolicyHeader, jsCallStacksDocumentPolicy)
+  return new Response(response.body, { status: response.status, statusText: response.statusText, headers })
+}
@@ -1,5 +1,5 @@
 import { contextBridge, ipcRenderer, webUtils } from "electron"
-import { DragCancelEvent, IpcTransportPort } from "../shared/ipc-transport"
+import { DragCancelEvent, IpcTransportPort, IpcTransportPortRequest } from "../shared/ipc-transport"
 import { windowIDFromArguments } from "../shared/window-bootstrap"

 ipcRenderer.on(IpcTransportPort, (event) => {
@@ -11,5 +11,6 @@ ipcRenderer.on(DragCancelEvent, () => window.dispatchEvent(new Event(DragCancelE

 contextBridge.exposeInMainWorld("electron", {
  windowID: windowIDFromArguments(process.argv),
+  requestRpcPort: () => ipcRenderer.send(IpcTransportPortRequest),
  getPathForFile: (file: File) => webUtils.getPathForFile(file),
 })
@@ -1,4 +1,5 @@
 export type ElectronNative = {
  windowID: string
+  requestRpcPort(): void
  getPathForFile(file: File): string
 }
@@ -54,6 +54,8 @@ export type ElectronAPI = {
  draftBlobGet(id: string): Promise<ArrayBuffer | null>
  getWindowID(): string
  themeReady(): Promise<void>
+  // Persists the sanitized shell markup the next launch shows before the renderer boots.
+  savePrepaint(html: string): Promise<void>
  onMenuCommand(cb: (id: string) => void): () => void
  onDeepLink(cb: (urls: string[]) => void): () => void
  openDirectoryPicker(opts?: DirectoryPickerOptions): Promise<string | string[] | null>
@@ -112,6 +112,7 @@ export const api: ElectronAPI = {

  getWindowID: () => window.electron.windowID,
  themeReady: () => invoke("WindowThemeReady"),
+  savePrepaint: (html) => invoke("WindowSavePrepaint", { html }),
  onMenuCommand: (cb) => listen("MenuCommandTriggered", (event) => cb(event.id)),
  onDeepLink: (cb) => listen("DeepLinksOpened", (event) => cb(mutable(event.urls))),

@@ -19,7 +19,7 @@ import {
 } from "@opencode/app/desktop"
 import { useTheme } from "@opencode/ui/theme/context"
 import type { BaseRouterProps } from "@solidjs/router"
-import { createEffect, createMemo, createResource, lazy, Show, Suspense } from "solid-js"
+import { createEffect, createMemo, createResource, lazy, on, Show, Suspense } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { ElectronAPI } from "./api-types"
 import { DesktopFirstLaunchOnboarding } from "./onboarding"
@@ -27,6 +27,7 @@ import { createDesktopPlatform } from "./platform"
 import { bindDesktopMenu } from "./platform/menu"
 import { createSidecarResolver, initializationData, sidecarHttp } from "./startup/initialization"
 import { preloadStoredLocale } from "./startup/locale"
+import { hasPrepaint, removePrepaint, schedulePrepaintCapture } from "./startup/prepaint"
 import { LoadingSplash } from "./startup/splash"
 import { getLastActiveUrl } from "./window/route-storage"
 import { DesktopMemoryRouter } from "./window/router"
@@ -40,9 +41,12 @@ export function DesktopApp(props: { api: ElectronAPI; updater: UpdaterPlatform;
  const initialUrl = getLastActiveUrl(windowState.id)
  const url = new URL(initialUrl, "http://localhost")
  const route = currentRoute(url.pathname, url.search)
+  // With a shell snapshot on screen the splash is not needed; the snapshot is removed when the
+  // interface would otherwise be revealed.
+  const prepaint = hasPrepaint()
  const [startup, setStartup] = createStore({
    ready: false,
-    visible: true,
+    visible: !prepaint,
    themeReady: false,
    onboardingReady: false,
    drawingReady: false,
@@ -72,6 +76,25 @@ export function DesktopApp(props: { api: ElectronAPI; updater: UpdaterPlatform;
    if (!startup.themeReady || firstLaunch.loading) return
    void props.api.themeReady()
  })
+  createEffect(() => {
+    if (!prepaint || firstLaunch() !== true) return
+    removePrepaint()
+    setStartup("visible", true)
+  })
+  createEffect(() => {
+    if (!readyToReveal()) return
+    removePrepaint()
+    schedulePrepaintCapture(props.api.savePrepaint)
+  })
+  createEffect(
+    on(
+      () => startup.route,
+      () => {
+        if (startup.ready) schedulePrepaintCapture(props.api.savePrepaint, 3000)
+      },
+      { defer: true },
+    ),
+  )

  function ReadyApp() {
    const wslServers = useWslServers()
@@ -13,6 +13,8 @@ type InvokeResult<Tag extends InvokeTag> =
  ReturnType<DesktopRpcClient[Tag]> extends Effect.Effect<infer Value, unknown> ? Value : never
 type EventValue<Tag extends EventTag> = Extract<DesktopEvent, { readonly _tag: Tag }>

+// The renderer asks for its port rather than receiving one on load: the first window's document
+// is on screen before its scripts, and before the main process has its IPC layer, exist.
 const port = new Promise<MessagePort>((resolve) => {
  const onMessage = (event: MessageEvent) => {
    if (event.source !== window || event.data !== IpcTransportPort) return
@@ -22,6 +24,7 @@ const port = new Promise<MessagePort>((resolve) => {
    resolve(value)
  }
  window.addEventListener("message", onMessage)
+  window.electron.requestRpcPort()
 })

 const ClientProtocolLive = Layer.unwrap(Effect.promise(() => port).pipe(Effect.map((value) => clientProtocol(value))))
@@ -0,0 +1,72 @@
+// The early document carries a static copy of this window's shell from the previous run, served by
+// the main process as #oc-prepaint, so the user sees their UI while the renderer boots. It is
+// removed when the real interface is ready to be revealed, and re-captured from the live DOM so the
+// next launch shows the current state.
+
+const prepaintID = "oc-prepaint"
+const maxBytes = 1_000_000
+
+export function hasPrepaint() {
+  return document.getElementById(prepaintID) !== null
+}
+
+export function removePrepaint() {
+  document.getElementById(prepaintID)?.remove()
+}
+
+let timer: number | undefined
+
+// Captures once the renderer is idle; `delay` coalesces bursts of route changes into one capture.
+export function schedulePrepaintCapture(save: (html: string) => Promise<void>, delay = 0) {
+  clearTimeout(timer)
+  timer = window.setTimeout(() => {
+    requestIdleCallback(
+      () => {
+        const root = document.getElementById("root")
+        const html = root && capturePrepaint(root)
+        if (html) void save(html).catch(() => undefined)
+      },
+      { timeout: 2000 },
+    )
+  }, delay)
+}
+
+// Elements that hold live or transient state and would look wrong, or leak, in a static copy.
+const dropped =
+  "script, style, link, iframe, object, embed, canvas, video, audio, dialog, [popover], [role='dialog'], [role='menu'], [role='listbox'], [role='tooltip'], [data-component='startup-overlay']"
+// Attributes that could act, be targeted, or collide with the live document once it mounts.
+const stripped = new Set(["id", "href", "tabindex", "contenteditable", "autofocus", "for", "name", "action", "formaction"])
+
+export function capturePrepaint(root: HTMLElement) {
+  const clone = root.cloneNode(true) as HTMLElement
+  clone.querySelectorAll(dropped).forEach((element) => element.remove())
+  const symbols = new Set<string>()
+  for (const element of clone.querySelectorAll("*")) {
+    if (element instanceof HTMLTextAreaElement || element instanceof HTMLInputElement) element.removeAttribute("value")
+    if (element.hasAttribute("contenteditable")) element.replaceChildren()
+    for (const attribute of Array.from(element.attributes)) {
+      const name = attribute.name
+      if (name.startsWith("on")) element.removeAttribute(name)
+      // SVG keeps its ids and hrefs: gradients, clip paths and <use> references are local visuals.
+      if (element instanceof SVGElement) {
+        if (name === "href" && attribute.value.startsWith("#")) symbols.add(attribute.value.slice(1))
+        continue
+      }
+      if (stripped.has(name)) element.removeAttribute(name)
+      if (name === "src" && !/^(\.\/|\/|oc:|data:)/.test(attribute.value)) element.removeAttribute(name)
+    }
+  }
+  const root_ = document.documentElement
+  const html = `<div class="${document.body.className} flex flex-col h-dvh" lang="${root_.lang}" dir="${root_.dir}">${sprite(symbols)}${clone.innerHTML}</div>`
+  return html.length <= maxBytes ? html : undefined
+}
+
+// Icons are <use href="#symbol"> into a sprite outside #root; copy only the symbols the shell uses.
+function sprite(symbols: Set<string>) {
+  const defs = [...symbols]
+    .map((id) => document.getElementById(id))
+    .filter((element) => element instanceof SVGSymbolElement)
+    .map((element) => element.outerHTML)
+  if (!defs.length) return ""
+  return `<svg aria-hidden="true" width="0" height="0" style="position:absolute;overflow:hidden">${defs.join("")}</svg>`
+}
@@ -24,6 +24,9 @@ export const WindowSetTitlebar = Rpc.make("WindowSetTitlebar", {
    }),
  },
 })
+export const WindowSavePrepaint = Rpc.make("WindowSavePrepaint", {
+  payload: { html: Schema.String },
+})
 export const WindowRpcs = RpcGroup.make(
  WindowThemeReady,
  WindowGetFocused,
@@ -35,4 +38,5 @@ export const WindowRpcs = RpcGroup.make(
  WindowGetPinchZoomEnabled,
  WindowSetPinchZoomEnabled,
  WindowSetTitlebar,
+  WindowSavePrepaint,
 )
@@ -1,2 +1,3 @@
 export const IpcTransportPort = "desktop-rpc-port"
+export const IpcTransportPortRequest = "desktop-rpc-port-request"
 export const DragCancelEvent = "opencode:drag-cancel"
@@ -13251,27 +13251,6 @@
        "required": ["input", "output"],
        "additionalProperties": false
      },
-      "Config.Model.Settings": {
-        "type": "object",
-        "properties": {
-          "compaction": {
-            "$ref": "#/components/schemas/Provider.Compaction"
-          }
-        },
-        "allOf": [
-          {
-            "type": "object",
-            "additionalProperties": {
-              "anyOf": [
-                {},
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          }
-        ]
-      },
      "Config.ModelEncoded": {
        "type": "object",
        "properties": {
@@ -13291,7 +13270,7 @@
            "type": "string"
          },
          "settings": {
-            "$ref": "#/components/schemas/Config.Model.Settings"
+            "$ref": "#/components/schemas/Config.Provider.Settings"
          },
          "headers": {
            "type": "object",
@@ -13314,7 +13293,7 @@
                  "type": "string"
                },
                "settings": {
-                  "$ref": "#/components/schemas/Config.Model.Settings"
+                  "$ref": "#/components/schemas/Config.Provider.Settings"
                },
                "headers": {
                  "type": "object",
@@ -15529,7 +15508,7 @@
            "type": "string"
          },
          "settings": {
-            "$ref": "#/components/schemas/Model.Settings"
+            "$ref": "#/components/schemas/Provider.Settings"
          },
          "headers": {
            "type": "object",
@@ -15635,20 +15614,6 @@
        "required": ["id", "providerID"],
        "additionalProperties": false
      },
-      "Model.Settings": {
-        "type": "object",
-        "properties": {
-          "compaction": {
-            "$ref": "#/components/schemas/Provider.Compaction"
-          }
-        },
-        "allOf": [
-          {
-            "type": "object",
-            "additionalProperties": {}
-          }
-        ]
-      },
      "Model.Variant": {
        "type": "object",
        "properties": {
@@ -15656,7 +15621,7 @@
            "type": "string"
          },
          "settings": {
-            "$ref": "#/components/schemas/Model.Settings"
+            "$ref": "#/components/schemas/Provider.Settings"
          },
          "headers": {
            "type": "object",
@@ -17,14 +17,6 @@ export const Settings = Schema.StructWithRest(
 ).annotate({ identifier: "Config.Provider.Settings" })
 export type Settings = typeof Settings.Type

-export const ModelSettings = Schema.StructWithRest(
-  Schema.Struct({
-    compaction: Provider.Compaction.pipe(optional),
-  }),
-  [Schema.Record(Schema.String, Schema.UndefinedOr(Schema.Json))],
-).annotate({ identifier: "Config.Model.Settings" })
-export type ModelSettings = typeof ModelSettings.Type
-
 const JsonRecord = Schema.Record(Schema.String, Schema.Json)

 export const Overlays = {
@@ -33,12 +25,6 @@ export const Overlays = {
  body: JsonRecord.pipe(optional),
 }

-const ModelOverlays = {
-  settings: ModelSettings.pipe(optional),
-  headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
-  body: JsonRecord.pipe(optional),
-}
-
 export class Request extends Schema.Class<Request>("Config.Provider.Request")({
  headers: Overlays.headers,
  body: Overlays.body,
@@ -71,11 +57,11 @@ class Model extends Schema.Class<Model>("Config.Model")({
  name: Schema.String.pipe(optional),
  compatibility: Compatibility.pipe(optional),
  package: Schema.String.pipe(optional),
-  ...ModelOverlays,
+  ...Overlays,
  capabilities: Capabilities.pipe(optional),
  variants: Schema.Struct({
    id: VariantID,
-    ...ModelOverlays,
+    ...Overlays,
  }).pipe(Schema.Array, optional),
  cost: Schema.Union([Cost, Cost.pipe(Schema.Array)]).pipe(optional),
  disabled: Schema.Boolean.pipe(optional),
@@ -56,21 +56,6 @@ export const MaxTokensField = Schema.Literals(["max_completion_tokens", "max_tok
 })
 export type MaxTokensField = typeof MaxTokensField.Type

-export const Settings = Schema.StructWithRest(
-  Schema.Struct({
-    compaction: Provider.Compaction.pipe(optional),
-  }),
-  // Provider packages may define arbitrary model-level options beyond OpenCode's shared compaction policy.
-  [Schema.Record(Schema.String, Schema.Any)],
-).annotate({ identifier: "Model.Settings" })
-export type Settings = typeof Settings.Type
-
-export const Overlays = {
-  settings: Settings.pipe(optional),
-  headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
-  body: Schema.Record(Schema.String, Schema.Any).pipe(optional),
-}
-
 export interface Compatibility extends Schema.Schema.Type<typeof Compatibility> {}
 export const Compatibility = Schema.Struct({
  reasoningField: ReasoningField.pipe(optional),
@@ -112,7 +97,7 @@ export const Cost = Schema.Struct({
 export interface Variant extends Schema.Schema.Type<typeof Variant> {}
 export const Variant = Schema.Struct({
  id: VariantID,
-  ...Overlays,
+  ...Provider.Overlays,
 }).annotate({ identifier: "Model.Variant" })

 export interface Info extends Schema.Schema.Type<typeof Info> {}
@@ -125,7 +110,7 @@ export const Info = Schema.Struct({
  name: Schema.String,
  compatibility: Compatibility.pipe(optional),
  package: Provider.Package.pipe(optional),
-  ...Overlays,
+  ...Provider.Overlays,
  capabilities: Capabilities,
  variants: Schema.Array(Variant),
  time: Schema.Struct({
@@ -169,7 +169,6 @@ describe("contract hygiene", () => {
  test("reusable public identifiers are stable and unique", () => {
    const identifiers = [
      Agent.Color,
-      ConfigProvider.ModelSettings,
      ConfigProvider.Settings,
      FileSystem.Submatch,
      Form.Field,
@@ -184,7 +183,6 @@ describe("contract hygiene", () => {
      Model.Ref,
      Model.Capabilities,
      Model.Cost,
-      Model.Settings,
      Model.Variant,
      Project.Current,
      Worktree.Directory,
@@ -241,12 +239,11 @@ describe("contract hygiene", () => {

    expect(
      sources
-        .filter((item) => item.file !== "provider.ts" && item.file !== "model.ts" && item.file !== "integration.ts")
+        .filter((item) => item.file !== "provider.ts" && item.file !== "integration.ts")
        .map((item) => item.source)
        .join("\n"),
    ).not.toContain("Schema.Any")
    expect(sources.find((item) => item.file === "provider.ts")?.source.match(/Schema\.Any/g)).toHaveLength(3)
-    expect(sources.find((item) => item.file === "model.ts")?.source.match(/Schema\.Any/g)).toHaveLength(2)
    expect(sources.find((item) => item.file === "integration.ts")?.source.match(/Schema\.Any/g)).toHaveLength(2)
    expect(source).not.toContain("Schema.mutable")
  })
@@ -75,10 +75,13 @@ describe("Model.Info", () => {
  })
 })

-describe("Model.Settings", () => {
-  test("preserves provider-specific model options", () => {
-    expect(Schema.decodeUnknownSync(Model.Settings)({ providerOption: true })).toEqual({
-      providerOption: true,
+describe("Model.Capabilities", () => {
+  test("decodes the optional transport setting", () => {
+    const model = Model.Info.default(Provider.ID.openai, Model.ID.make("gpt-5.4-mini"))
+    expect(Schema.encodeSync(Model.Info)({ ...model, settings: { transport: undefined } }).settings).toEqual({})
+    expect(Schema.decodeUnknownSync(Model.Info)({ ...model, settings: { transport: "websocket" } }).settings).toEqual({
+      transport: "websocket",
    })
+    expect(() => Schema.decodeUnknownSync(Model.Info)({ ...model, settings: { transport: "sse" } })).toThrow()
  })
 })
@@ -13251,27 +13251,6 @@
        "required": ["input", "output"],
        "additionalProperties": false
      },
-      "Config.Model.Settings": {
-        "type": "object",
-        "properties": {
-          "compaction": {
-            "$ref": "#/components/schemas/Provider.Compaction"
-          }
-        },
-        "allOf": [
-          {
-            "type": "object",
-            "additionalProperties": {
-              "anyOf": [
-                {},
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          }
-        ]
-      },
      "Config.ModelEncoded": {
        "type": "object",
        "properties": {
@@ -13291,7 +13270,7 @@
            "type": "string"
          },
          "settings": {
-            "$ref": "#/components/schemas/Config.Model.Settings"
+            "$ref": "#/components/schemas/Config.Provider.Settings"
          },
          "headers": {
            "type": "object",
@@ -13314,7 +13293,7 @@
                  "type": "string"
                },
                "settings": {
-                  "$ref": "#/components/schemas/Config.Model.Settings"
+                  "$ref": "#/components/schemas/Config.Provider.Settings"
                },
                "headers": {
                  "type": "object",
@@ -15529,7 +15508,7 @@
            "type": "string"
          },
          "settings": {
-            "$ref": "#/components/schemas/Model.Settings"
+            "$ref": "#/components/schemas/Provider.Settings"
          },
          "headers": {
            "type": "object",
@@ -15635,20 +15614,6 @@
        "required": ["id", "providerID"],
        "additionalProperties": false
      },
-      "Model.Settings": {
-        "type": "object",
-        "properties": {
-          "compaction": {
-            "$ref": "#/components/schemas/Provider.Compaction"
-          }
-        },
-        "allOf": [
-          {
-            "type": "object",
-            "additionalProperties": {}
-          }
-        ]
-      },
      "Model.Variant": {
        "type": "object",
        "properties": {
@@ -15656,7 +15621,7 @@
            "type": "string"
          },
          "settings": {
-            "$ref": "#/components/schemas/Model.Settings"
+            "$ref": "#/components/schemas/Provider.Settings"
          },
          "headers": {
            "type": "object",
@@ -13251,27 +13251,6 @@
        "required": ["input", "output"],
        "additionalProperties": false
      },
-      "Config.Model.Settings": {
-        "type": "object",
-        "properties": {
-          "compaction": {
-            "$ref": "#/components/schemas/Provider.Compaction"
-          }
-        },
-        "allOf": [
-          {
-            "type": "object",
-            "additionalProperties": {
-              "anyOf": [
-                {},
-                {
-                  "type": "null"
-                }
-              ]
-            }
-          }
-        ]
-      },
      "Config.ModelEncoded": {
        "type": "object",
        "properties": {
@@ -13291,7 +13270,7 @@
            "type": "string"
          },
          "settings": {
-            "$ref": "#/components/schemas/Config.Model.Settings"
+            "$ref": "#/components/schemas/Config.Provider.Settings"
          },
          "headers": {
            "type": "object",
@@ -13314,7 +13293,7 @@
                  "type": "string"
                },
                "settings": {
-                  "$ref": "#/components/schemas/Config.Model.Settings"
+                  "$ref": "#/components/schemas/Config.Provider.Settings"
                },
                "headers": {
                  "type": "object",
@@ -15529,7 +15508,7 @@
            "type": "string"
          },
          "settings": {
-            "$ref": "#/components/schemas/Model.Settings"
+            "$ref": "#/components/schemas/Provider.Settings"
          },
          "headers": {
            "type": "object",
@@ -15635,20 +15614,6 @@
        "required": ["id", "providerID"],
        "additionalProperties": false
      },
-      "Model.Settings": {
-        "type": "object",
-        "properties": {
-          "compaction": {
-            "$ref": "#/components/schemas/Provider.Compaction"
-          }
-        },
-        "allOf": [
-          {
-            "type": "object",
-            "additionalProperties": {}
-          }
-        ]
-      },
      "Model.Variant": {
        "type": "object",
        "properties": {
@@ -15656,7 +15621,7 @@
            "type": "string"
          },
          "settings": {
-            "$ref": "#/components/schemas/Model.Settings"
+            "$ref": "#/components/schemas/Provider.Settings"
          },
          "headers": {
            "type": "object",
@@ -506,6 +506,7 @@ headers, and model variants.
 }
 ```

-Provider `settings.transport: "websocket"` selects its session WebSocket.
+`settings.transport: "websocket"` on a provider or model selects its session
+WebSocket; a model value overrides the provider value.

 See the [providers guide](/providers) for credentials, custom endpoints, provider packages, the WebSocket transport, and model configuration.
@@ -558,6 +558,9 @@ sessions.
  "providers": {
    "openai": {
      "settings": { "transport": "http" },
+      "models": {
+        "gpt-5.5": { "settings": { "transport": "websocket" } },
+      },
    },
  },
 }
@@ -565,8 +568,9 @@ sessions.

 WebSocket behavior follows these rules:

- Built-in providers opt supported routes in according to their own policy.
- Provider `settings.transport: "websocket"` enables it; `"http"` disables it.
+- Built-in providers opt supported models in according to their own policy.
+- `settings.transport: "websocket"` enables a provider or model; `"http"` disables it.
+- A model value overrides its provider value.
 - `"websocket"` on a route without a WebSocket channel logs a warning and falls back to HTTP.
 - OpenAI provider compaction uses the same connection.
 - xAI continues from stored responses only. With its default `store: false`, each step is sent in full over the reused