From 53d171781a5d46457750063f99d892308ff29726 Mon Sep 17 00:00:00 2001 From: Luke Parker <10430890+Hona@users.noreply.github.com> Date: Thu, 27 Aug 2026 09:30:49 +1000 Subject: [PATCH] fix(app): reduce catalog retention and status animation work (#45406) --- packages/app/e2e/performance/README.md | 12 +++ .../provider-memory-benchmark.spec.ts | 98 ++++++++++++++++++ packages/app/e2e/utils/mock-server.ts | 2 + .../src/runtime/server/global-sync/utils.ts | 28 +++-- .../app/test-browser/provider-catalog.test.ts | 52 ++++++++++ .../generate-session-progress-indicator.ts | 6 +- .../session-progress-indicator-v2-1x.png | Bin 11540 -> 3876 bytes .../session-progress-indicator-v2.test.ts | 35 +++++++ 8 files changed, 224 insertions(+), 9 deletions(-) create mode 100644 packages/app/e2e/performance/timeline/provider-memory-benchmark.spec.ts create mode 100644 packages/app/test-browser/provider-catalog.test.ts create mode 100644 packages/session-ui/src/v2/components/session-progress-indicator-v2.test.ts 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 b9fe7a73ec8afb45ba8a6432be7e8024484ed624..fc158c80f04fe02824d8a17d67b6230a2d7cb990 100644 GIT binary patch delta 1449 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 JPQ@#?{SSmEi=O}h 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) +})