diff --git a/packages/app/e2e/performance/README.md b/packages/app/e2e/performance/README.md index 78bf8f3ab0c..26494e89b8f 100644 --- a/packages/app/e2e/performance/README.md +++ b/packages/app/e2e/performance/README.md @@ -44,6 +44,7 @@ The suite contains: - single-session tab close timing through stable home restoration - cached session repaint and mutation tracing - streaming timeline throughput, RAF-gap, long-task, geometry, and remount diagnostics +- retained renderer heap with a large model catalog across repeated session navigation All benchmarks import the shared `benchmark` fixture. Pages created through Playwright's `page` fixture automatically capture main-frame navigation history and emit a Chrome trace when `OPENCODE_PERFORMANCE_TRACE_DIR` is set. Benchmarks that need isolated browser contexts use `withBenchmarkPage`, which owns the context and the same diagnostics lifecycle. @@ -78,6 +79,17 @@ Benchmarks do not assert machine-dependent performance budgets. Streaming proces Committed smoke and regression tests continue to own correctness coverage for pagination, tab paint, context resize, collapse state, and composer spacing. +## Retained renderer memory + +Run the catalog workload against the production app bundle: + +```sh +bunx playwright test --config e2e/performance/playwright.config.ts \ + timeline/provider-memory-benchmark.spec.ts --repeat-each=3 +``` + +`PROVIDER_MEMORY_MODELS` defaults to 1,200 and `PROVIDER_MEMORY_SWITCHES` defaults to 10. Each sample records Chromium's `Runtime.getHeapUsage` and `Memory.getDOMCounters` after an explicit garbage collection. This measures retained state, not allocation peaks or normal GC timing. It does not include worker heaps, the Electron main/GPU processes, or the OpenCode server, and must not be reported as total desktop RAM. Use identical model counts and navigation sequences for before/after comparisons. + ## Chrome traces Set `OPENCODE_PERFORMANCE_TRACE_DIR` to emit a standard Chrome DevTools trace for every benchmark page automatically: diff --git a/packages/app/e2e/performance/timeline/provider-memory-benchmark.spec.ts b/packages/app/e2e/performance/timeline/provider-memory-benchmark.spec.ts new file mode 100644 index 00000000000..e56fcb1c186 --- /dev/null +++ b/packages/app/e2e/performance/timeline/provider-memory-benchmark.spec.ts @@ -0,0 +1,98 @@ +import { benchmark, expect } from "../benchmark" +import { mockOpenCodeServer } from "../../utils/mock-server" +import { expectSessionTitle } from "../../utils/waits" +import { fixture, pageMessages } from "./session-timeline-stress.fixture" +import { installStressSessionTabs, installTimelineSettings, stressSessionHref } from "./timeline-test-helpers" +import { waitForStableTimeline } from "./session-tab-switch-probe" +import type { CatalogUpdated } from "@opencode-ai/client/promise" + +benchmark("measures retained renderer memory with a large model catalog", async ({ page, report }) => { + benchmark.setTimeout(120_000) + const count = Number(process.env.PROVIDER_MEMORY_MODELS ?? 1200) + const switches = Number(process.env.PROVIDER_MEMORY_SWITCHES ?? 10) + const provider = fixture.provider.all[0] + const selected = { ...provider.models["claude-opus-4-6"] } + await mockOpenCodeServer(page, { + directory: fixture.directory, + project: fixture.project, + sessions: fixture.sessions, + pageMessages, + provider: { + ...fixture.provider, + all: [ + { + ...provider, + models: { + [selected.id]: selected, + ...Object.fromEntries( + Array.from({ length: count - 1 }, (_, index) => { + const id = `catalog-model-${index}` + return [ + id, + { + id, + name: `Catalog model ${index}`, + cost: { input: 1, output: 2 }, + limit: { context: 200_000, output: 8192 }, + variants: { high: { reasoningEffort: "high" } }, + }, + ] + }), + ), + }, + }, + ], + }, + }) + await installTimelineSettings(page) + await installStressSessionTabs(page) + await page.goto(stressSessionHref(fixture.sourceID)) + await expectSessionTitle(page, fixture.expected.sourceTitle) + await waitForStableTimeline(page, fixture.expected.sourceMessageIDs.at(-1)!) + await expect(page.locator('[data-action="composer-model"]')).toContainText("Claude Opus 4.6") + const cdp = await page.context().newCDPSession(page) + const samples = [] + for (let index = 0; index <= switches; index++) { + if (index > 0) { + const target = index % 2 === 1 + const id = target ? fixture.targetID : fixture.sourceID + await page.locator(`[data-slot="titlebar-tabs"] a[href="${stressSessionHref(id)}"]`).click() + await expectSessionTitle(page, target ? fixture.expected.targetTitle : fixture.expected.sourceTitle) + await waitForStableTimeline( + page, + (target ? fixture.expected.targetMessageIDs : fixture.expected.sourceMessageIDs).at(-1)!, + ) + await expect(page.locator('[data-action="composer-model"]')).toContainText("Claude Opus 4.6") + } + // GC is an explicit retained-heap measurement, not an application optimization or readiness wait. + await cdp.send("HeapProfiler.collectGarbage") + samples.push({ + switches: index, + heap: await cdp.send("Runtime.getHeapUsage"), + dom: await cdp.send("Memory.getDOMCounters"), + }) + } + expect(samples).toHaveLength(switches + 1) + expect(samples.every((sample) => sample.heap.usedSize > 0)).toBe(true) + selected.name = "Updated catalog model" + await page.evaluate( + (event) => { + const host = window as Window & { __mockServerStream?: { push: (events: CatalogUpdated[]) => void } } + if (!host.__mockServerStream) throw new Error("Missing fixture event stream") + host.__mockServerStream.push([event]) + }, + { + id: "evt_catalog_refresh", + created: Date.now(), + type: "catalog.updated", + location: { directory: fixture.directory }, + data: {}, + } satisfies CatalogUpdated, + ) + await expect(page.locator('[data-action="composer-model"]')).toContainText(selected.name) + report( + { samples }, + { models: count, switches, gc: "explicit", scope: "renderer main isolate; not total desktop RAM" }, + ) + await cdp.detach() +}) diff --git a/packages/app/e2e/utils/mock-server.ts b/packages/app/e2e/utils/mock-server.ts index 33cb846304d..6f9ff810987 100644 --- a/packages/app/e2e/utils/mock-server.ts +++ b/packages/app/e2e/utils/mock-server.ts @@ -150,6 +150,8 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) { process.env.PLAYWRIGHT_BASE_URL ?? `http://127.0.0.1:${process.env.PLAYWRIGHT_PORT ?? "3000"}`, ).port if (url.origin !== server && url.port !== appPort) return route.fallback() + // Production serves the UI and API from one origin; leave app assets to Vite. + if (!url.pathname.startsWith("/api/")) return route.fallback() if (route.request().method() === "OPTIONS") { return route.fulfill({ status: 204, headers: corsHeaders }) } diff --git a/packages/app/src/runtime/server/global-sync/utils.ts b/packages/app/src/runtime/server/global-sync/utils.ts index e0f36536bfd..3cddc558a21 100644 --- a/packages/app/src/runtime/server/global-sync/utils.ts +++ b/packages/app/src/runtime/server/global-sync/utils.ts @@ -1,10 +1,16 @@ import type { AgentListOutput, ModelListOutput, ProviderListOutput } from "@opencode-ai/client/promise" import type { Agent, Project, Provider, ProviderListResponse } from "@/runtime/server/types" import type { Project as CurrentProject } from "@opencode-ai/client/promise" +import { unwrap } from "solid-js/store" export { pathKey as directoryKey, type PathKey as DirectoryKey } from "@/workspaces/path-key" export const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0) +const providerCatalogs = new WeakMap< + ProviderListOutput["data"], + WeakMap +>() + export function normalizeAgentList(input: AgentListOutput["data"] | Agent[]): Agent[] { if (input.every((agent) => !("request" in agent))) return input as Agent[] return (input as AgentListOutput["data"]).map((agent) => ({ @@ -30,12 +36,16 @@ export function normalizeAgentList(input: AgentListOutput["data"] | Agent[]): Ag } export function normalizeProviderList( - providers: ProviderListOutput["data"] | ProviderListResponse, - models?: ModelListOutput["data"], + input: ProviderListOutput["data"] | ProviderListResponse, + catalog?: ModelListOutput["data"], ): ProviderListResponse { - if (!Array.isArray(providers)) { - return providers - } + if (!Array.isArray(input)) return input + // Client sync replaces whole catalog lists. Track those reads at the caller, + // not every model field, and share conversions without retaining old lists. + const providers = unwrap(input) + const models = unwrap(catalog) + const cached = models && providerCatalogs.get(providers)?.get(models) + if (cached) return cached const all = new Map() for (const provider of providers) { @@ -101,7 +111,7 @@ export function normalizeProviderList( } } - return { + const result = { all, connected: providers.map((provider) => provider.id), default: Object.fromEntries( @@ -111,6 +121,12 @@ export function normalizeProviderList( }), ), } + if (models) { + const cache = providerCatalogs.get(providers) ?? new WeakMap() + cache.set(models, result) + providerCatalogs.set(providers, cache) + } + return result } export function normalizeProjectInfo(project: Project | CurrentProject): Project { diff --git a/packages/app/test-browser/provider-catalog.test.ts b/packages/app/test-browser/provider-catalog.test.ts new file mode 100644 index 00000000000..d81189393a9 --- /dev/null +++ b/packages/app/test-browser/provider-catalog.test.ts @@ -0,0 +1,52 @@ +import { expect, test } from "bun:test" +import { createMemo, createRoot } from "solid-js" +import { createStore } from "solid-js/store" +import { normalizeProviderList } from "@/runtime/server/global-sync/utils" + +test("preserves an already normalized reactive catalog", () => { + const [store] = createStore({ catalog: { all: new Map(), connected: [], default: {} } }) + expect(normalizeProviderList(store.catalog)).toBe(store.catalog) +}) + +test("shares catalog snapshots and reacts to replacement lists", () => { + createRoot((dispose) => { + const provider = { id: "openai", name: "OpenAI", package: "@ai-sdk/openai", activation: "enabled" as const } + const model = { + id: "gpt-5", + modelID: "gpt-5", + providerID: "openai", + name: "GPT-5", + settings: {}, + headers: {}, + capabilities: { tools: true, input: ["text" as const], output: ["text" as const] }, + variants: [], + time: { released: 1 }, + cost: [], + status: "active" as const, + enabled: true, + limit: { context: 128_000, output: 8192 }, + } + const [store, setStore] = createStore({ providers: [provider], models: [model] }) + const first = createMemo(() => normalizeProviderList(store.providers, store.models)) + const second = createMemo(() => normalizeProviderList(store.providers, store.models)) + expect(first()).toBe(second()) + const initial = first() + setStore("models", [{ ...model, name: "Renamed", limit: { context: 256_000, output: 16384 } }]) + expect(first()).not.toBe(initial) + expect(first()).toBe(second()) + expect(first().all.get("openai")?.models[model.id]).toMatchObject({ + name: "Renamed", + limit: { context: 256_000, output: 16384 }, + }) + const renamed = first() + setStore("providers", [{ ...provider, name: "Custom OpenAI" }]) + expect(first()).not.toBe(renamed) + expect(first()).toBe(second()) + expect(first().all.get("openai")?.name).toBe("Custom OpenAI") + expect(normalizeProviderList(store.providers).all.get("openai")?.models).toEqual({}) + setStore("models", []) + expect(first().all.get("openai")?.models).toEqual({}) + expect(first().default).toEqual({}) + dispose() + }) +}) diff --git a/packages/session-ui/script/generate-session-progress-indicator.ts b/packages/session-ui/script/generate-session-progress-indicator.ts index 9900244b87d..cc4664fdd57 100644 --- a/packages/session-ui/script/generate-session-progress-indicator.ts +++ b/packages/session-ui/script/generate-session-progress-indicator.ts @@ -1,7 +1,7 @@ import { deflateSync } from "node:zlib" const size = 16 -const frameRate = 90 +const frameRate = 30 const duration = 1.2 const frameCount = frameRate * duration const opacity = [0.2, 0.5, 0.75, 1] @@ -41,8 +41,8 @@ function apng(scale: number) { control.writeUInt32BE(sequence.value++, 0) control.writeUInt32BE(frameSize, 4) control.writeUInt32BE(frameSize, 8) - control.writeUInt16BE(frame % 9 === 0 ? 12 : 11, 20) - control.writeUInt16BE(1000, 22) + control.writeUInt16BE(1, 20) + control.writeUInt16BE(frameRate, 22) chunks.push(chunk("fcTL", control)) const data = deflateSync(pixels(scale, frame), { level: 9 }) diff --git a/packages/session-ui/src/v2/components/session-progress-indicator-v2-1x.png b/packages/session-ui/src/v2/components/session-progress-indicator-v2-1x.png index b9fe7a73ec8..fc158c80f04 100644 Binary files a/packages/session-ui/src/v2/components/session-progress-indicator-v2-1x.png and b/packages/session-ui/src/v2/components/session-progress-indicator-v2-1x.png differ diff --git a/packages/session-ui/src/v2/components/session-progress-indicator-v2.test.ts b/packages/session-ui/src/v2/components/session-progress-indicator-v2.test.ts new file mode 100644 index 00000000000..990235ec97e --- /dev/null +++ b/packages/session-ui/src/v2/components/session-progress-indicator-v2.test.ts @@ -0,0 +1,35 @@ +import { expect, test } from "bun:test" + +test("progress indicator PNG loops 36 frames at 30 fps in a 16x16 canvas", async () => { + const png = Buffer.from( + await Bun.file(new URL("./session-progress-indicator-v2-1x.png", import.meta.url)).arrayBuffer(), + ) + expect(png.subarray(0, 8)).toEqual(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) + + const chunks: { type: string; data: Buffer }[] = [] + for (let offset = 8; offset < png.length; ) { + const length = png.readUInt32BE(offset) + expect(offset + length + 12).toBeLessThanOrEqual(png.length) + chunks.push({ + type: png.toString("ascii", offset + 4, offset + 8), + data: png.subarray(offset + 8, offset + 8 + length), + }) + offset += length + 12 + } + + expect(chunks[0].type).toBe("IHDR") + expect(chunks[0].data.readUInt32BE(0)).toBe(16) + expect(chunks[0].data.readUInt32BE(4)).toBe(16) + expect(chunks.at(-1)?.type).toBe("IEND") + + const animation = chunks.filter((chunk) => chunk.type === "acTL") + expect(animation).toHaveLength(1) + expect(animation[0].data.readUInt32BE(0)).toBe(36) + expect(animation[0].data.readUInt32BE(4)).toBe(0) + + const frames = chunks.filter((chunk) => chunk.type === "fcTL") + expect(frames).toHaveLength(36) + const delays = frames.map((frame) => frame.data.readUInt16BE(20) / (frame.data.readUInt16BE(22) || 100)) + expect(delays.every((delay) => delay === 1 / 30)).toBe(true) + expect(delays.reduce((total, delay) => total + delay, 0)).toBeCloseTo(1.2, 10) +})