From e3c2e635a9d53f5299d1aa7728c1ff35f016d7e3 Mon Sep 17 00:00:00 2001 From: Luke Parker <10430890+Hona@users.noreply.github.com> Date: Wed, 2 Sep 2026 19:24:35 +1000 Subject: [PATCH] fix(session-ui): reuse cached diff highlighting across remounts (#46769) --- .../performance/highlighting/README.md | 39 +++++ .../performance/highlighting/build.ts | 28 ++++ .../highlighting/cache.correctness.ts | 35 +++++ .../performance/highlighting/index.html | 5 + .../highlighting/playwright.config.ts | 13 ++ .../performance/highlighting/serve.ts | 11 ++ .../performance/highlighting/viewer.bench.ts | 41 +++++ .../performance/highlighting/viewer.tsx | 145 ++++++++++++++++++ .../src/components/session-diff.test.ts | 32 ++++ .../session-ui/src/components/session-diff.ts | 14 +- 10 files changed, 362 insertions(+), 1 deletion(-) create mode 100644 packages/session-ui/performance/highlighting/README.md create mode 100644 packages/session-ui/performance/highlighting/build.ts create mode 100644 packages/session-ui/performance/highlighting/cache.correctness.ts create mode 100644 packages/session-ui/performance/highlighting/index.html create mode 100644 packages/session-ui/performance/highlighting/playwright.config.ts create mode 100644 packages/session-ui/performance/highlighting/serve.ts create mode 100644 packages/session-ui/performance/highlighting/viewer.bench.ts create mode 100644 packages/session-ui/performance/highlighting/viewer.tsx diff --git a/packages/session-ui/performance/highlighting/README.md b/packages/session-ui/performance/highlighting/README.md new file mode 100644 index 00000000000..06eec60ffa3 --- /dev/null +++ b/packages/session-ui/performance/highlighting/README.md @@ -0,0 +1,39 @@ +# Diff Highlighting + +Manual Chromium benchmark of the production `File` component, `normalize`, Pierre +pool, and bundled workers. No OpenCode server, session, or stored data is used. + +From `packages/session-ui`, set `HIGHLIGHT_BUNDLE` to an external artifact +directory, then run: + +```sh +bun performance/highlighting/build.ts +bun x playwright test --config performance/highlighting/playwright.config.ts --repeat-each 20 +``` + +Each isolated page measures a cold mount, unmount/remount of the identical patch, +and an edited patch under the same filename. The fixtures contain 120 or 1,200 +TypeScript route handlers with one changed line per ten handlers. Exact byte and +line counts, bundle hash, source revision, and individual samples are reported +through the existing performance reporter. + +`readyMs` ends when the viewer has called `onRendered`, its pool has settled, +and `onPostRender` has committed the final worker result containing the expected +edit. `firstReadyMs` records the earlier production callback, which can represent +plain first paint. Worker request counts and round-trip time describe the +mechanism, not CPU time or desktop memory. Full reconstructed content is checked +separately after timing. No forced GC or machine-dependent thresholds are used. + +`HIGHLIGHT_CORRECTNESS=1` runs the deterministic `*.correctness.ts` checks against +the same fixture instead of the timed benchmarks: cache reuse across remounts and +invalidation on content, theme, and worker option changes. + +Optional output settings: `HIGHLIGHT_RESULTS`, `HIGHLIGHT_SCREENSHOTS`, +`OPENCODE_PERFORMANCE_RUN_ID`, and `OPENCODE_PERFORMANCE_TRACE_DIR` (separate +diagnostic runs, not clean timing). `HIGHLIGHT_PORT` defaults to 4793. Preserve the +baseline build before product edits, then point `HIGHLIGHT_BUNDLE` at either frozen +build to compare the same workload without rebuilding. + +`HIGHLIGHT_RETENTION=1` enables a separate post-unmount, forced-GC renderer-isolate +heap diagnostic. Do not use that run for timing or describe it as desktop RAM; +it excludes worker heaps and native/browser-process memory. diff --git a/packages/session-ui/performance/highlighting/build.ts b/packages/session-ui/performance/highlighting/build.ts new file mode 100644 index 00000000000..4565941cc5d --- /dev/null +++ b/packages/session-ui/performance/highlighting/build.ts @@ -0,0 +1,28 @@ +import { build } from "vite" +import solid from "vite-plugin-solid" +import path from "node:path" +import { realpathSync } from "node:fs" +import { createHash } from "node:crypto" + +const outDir = process.env.HIGHLIGHT_BUNDLE +if (!outDir) throw new Error("Set HIGHLIGHT_BUNDLE to an external artifact directory") +const ui = realpathSync(path.resolve(import.meta.dir, "../../node_modules/@opencode-ai/ui")) +if (ui !== realpathSync(path.resolve(import.meta.dir, "../../../ui"))) throw new Error(`Wrong workspace source: ${ui}`) +const util = realpathSync(path.resolve(import.meta.dir, "../../node_modules/@opencode-ai/util")) +if (util !== realpathSync(path.resolve(import.meta.dir, "../../../util"))) throw new Error(`Wrong workspace source: ${util}`) +await build({ + configFile: false, + logLevel: "warn", + root: import.meta.dir, + plugins: [solid()], + build: { outDir, emptyOutDir: true, sourcemap: true }, + worker: { format: "es" }, +}) +const files = await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: outDir, onlyFiles: true })) +const hash = createHash("sha256") +for (const file of files.sort()) hash.update(file).update(new Uint8Array(await Bun.file(path.join(outDir, file)).arrayBuffer())) +await Bun.write(path.join(outDir, "build.json"), JSON.stringify({ + revision: Bun.spawnSync(["git", "rev-parse", "HEAD"]).stdout.toString().trim(), + sourceDiff: Bun.spawnSync(["git", "diff", "--", "src/components/session-diff.ts", "src/components/file.tsx", "src/pierre/worker.ts"]).stdout.toString(), + bundle: hash.digest("hex"), bun: Bun.version, ui, util, +}, null, 2)) diff --git a/packages/session-ui/performance/highlighting/cache.correctness.ts b/packages/session-ui/performance/highlighting/cache.correctness.ts new file mode 100644 index 00000000000..066caa7e858 --- /dev/null +++ b/packages/session-ui/performance/highlighting/cache.correctness.ts @@ -0,0 +1,35 @@ +import { expect, test } from "@playwright/test" +import type {} from "./viewer" + +test("reuses only matching patch, theme, and worker options", async ({ page }) => { + await page.goto("/") + await page.waitForFunction(() => !!window.highlighting) + const cold = await page.evaluate(() => window.highlighting.mount(1)) + expect(cold.workerRequests).toBe(1) + expect(cold.cacheSize).toBe(1) + const first = await page.locator('[data-line="11"][data-line-type="change-addition"]').innerHTML() + await page.evaluate(() => window.highlighting.unmount()) + + const cached = await page.evaluate(() => window.highlighting.mount(1)) + expect(cached.workerRequests).toBe(0) + expect(await page.locator('[data-line="11"][data-line-type="change-addition"]').innerHTML()).toBe(first) + await page.evaluate(() => window.highlighting.unmount()) + + const changed = await page.evaluate(() => window.highlighting.mount(2)) + expect(changed.workerRequests).toBe(1) + await expect(page.locator('[data-line="11"][data-line-type="change-addition"]')).toContainText("status: 202") + await page.evaluate(() => window.highlighting.unmount()) + + await page.evaluate(() => window.highlighting.configure({ theme: "github-dark" })) + const themed = await page.evaluate(() => window.highlighting.mount(2)) + expect(themed.workerRequests).toBe(1) + expect(themed.options.theme).toBe("github-dark") + expect(themed.cacheSize).toBe(1) + await page.evaluate(() => window.highlighting.unmount()) + + await page.evaluate(() => window.highlighting.configure({ tokenizeMaxLineLength: 1 })) + const plain = await page.evaluate(() => window.highlighting.mount(2)) + expect(plain.workerRequests).toBe(1) + expect(plain.options.tokenizeMaxLineLength).toBe(1) + expect(await page.evaluate(() => window.highlighting.contents()!.after === window.highlighting.input.after[1])).toBe(true) +}) diff --git a/packages/session-ui/performance/highlighting/index.html b/packages/session-ui/performance/highlighting/index.html new file mode 100644 index 00000000000..a5064b78626 --- /dev/null +++ b/packages/session-ui/performance/highlighting/index.html @@ -0,0 +1,5 @@ + + + Diff highlighting benchmark +
+ diff --git a/packages/session-ui/performance/highlighting/playwright.config.ts b/packages/session-ui/performance/highlighting/playwright.config.ts new file mode 100644 index 00000000000..99ba3cfc9c0 --- /dev/null +++ b/packages/session-ui/performance/highlighting/playwright.config.ts @@ -0,0 +1,13 @@ +import { defineConfig } from "@playwright/test" + +export default defineConfig({ + testDir: ".", testMatch: process.env.HIGHLIGHT_CORRECTNESS ? "*.correctness.ts" : "*.bench.ts", workers: 1, retries: 0, maxFailures: 1, timeout: 120_000, + outputDir: process.env.HIGHLIGHT_RESULTS, + reporter: [["line"]], + use: { baseURL: `http://127.0.0.1:${process.env.HIGHLIGHT_PORT ?? 4793}`, viewport: { width: 1280, height: 800 } }, + webServer: { + command: "bun serve.ts", + url: `http://127.0.0.1:${process.env.HIGHLIGHT_PORT ?? 4793}`, + reuseExistingServer: false, + }, +}) diff --git a/packages/session-ui/performance/highlighting/serve.ts b/packages/session-ui/performance/highlighting/serve.ts new file mode 100644 index 00000000000..cf7515ac72f --- /dev/null +++ b/packages/session-ui/performance/highlighting/serve.ts @@ -0,0 +1,11 @@ +import path from "node:path" + +const root = process.env.HIGHLIGHT_BUNDLE +if (!root) throw new Error("Set HIGHLIGHT_BUNDLE") +Bun.serve({ + hostname: "127.0.0.1", port: Number(process.env.HIGHLIGHT_PORT ?? 4793), + fetch(request) { + const pathname = new URL(request.url).pathname + return new Response(Bun.file(path.join(root, pathname === "/" ? "index.html" : pathname))) + }, +}) diff --git a/packages/session-ui/performance/highlighting/viewer.bench.ts b/packages/session-ui/performance/highlighting/viewer.bench.ts new file mode 100644 index 00000000000..2220e742492 --- /dev/null +++ b/packages/session-ui/performance/highlighting/viewer.bench.ts @@ -0,0 +1,41 @@ +import { benchmark, expect } from "../../../app/e2e/performance/benchmark" +import { readFile } from "node:fs/promises" +import path from "node:path" +import type {} from "./viewer" + +for (const large of [false, true]) { + benchmark(large ? "large file" : "normalized diff remount", async ({ page, browser, report }, info) => { + const errors: string[] = [] + page.on("pageerror", (error) => errors.push(error.message)) + await page.goto(large ? "/?large" : "/") + await page.waitForFunction(() => !!window.highlighting) + const cold = await page.evaluate(() => window.highlighting.mount(1)) + await expect(page.locator('[data-line="11"][data-line-type="change-addition"]')).toContainText("status: 201") + await page.evaluate(() => window.highlighting.unmount()) + const remount = await page.evaluate(() => window.highlighting.mount(1)) + await page.evaluate(() => window.highlighting.unmount()) + const changed = await page.evaluate(() => window.highlighting.mount(2)) + await expect(page.locator('[data-line="11"][data-line-type="change-addition"]')).toContainText("status: 202") + const complete = await page.evaluate(() => { + const contents = window.highlighting.contents()! + return contents.before === window.highlighting.input.before && contents.after === window.highlighting.input.after[1] + }) + expect(complete).toBe(true) + expect(errors).toEqual([]) + const retention = await (async () => { + if (!process.env.HIGHLIGHT_RETENTION) return + await page.evaluate(() => window.highlighting.unmount()) + const session = await page.context().newCDPSession(page) + await session.send("HeapProfiler.collectGarbage") + const heap = await session.send("Runtime.getHeapUsage") + await session.detach() + return heap + })() + report({ cold, remount, changed, retention }, { + browser: browser.version(), + dimensions: await page.evaluate(() => window.highlighting.dimensions), + build: JSON.parse(await readFile(path.join(process.env.HIGHLIGHT_BUNDLE!, "build.json"), "utf8")), + }) + if (process.env.HIGHLIGHT_SCREENSHOTS) await page.screenshot({ path: path.join(process.env.HIGHLIGHT_SCREENSHOTS, `${large ? "large" : "diff"}-${info.repeatEachIndex}.png`) }) + }) +} diff --git a/packages/session-ui/performance/highlighting/viewer.tsx b/packages/session-ui/performance/highlighting/viewer.tsx new file mode 100644 index 00000000000..1d0569db286 --- /dev/null +++ b/packages/session-ui/performance/highlighting/viewer.tsx @@ -0,0 +1,145 @@ +import { render } from "solid-js/web" +import { createPatch } from "diff" +import type { WorkerRequest, WorkerResponse, WorkerRenderingOptions } from "@pierre/diffs/worker" +import type { RenderDiffOptions } from "@pierre/diffs" +import { File } from "../../src/components/file" +import { normalize, text } from "../../src/components/session-diff" +import { getWorkerPool } from "../../src/pierre/worker" +import "../../../ui/src/styles/theme.css" + +// This fixture uses the production component, normalizer, pool, and worker bundle. +// Observe messages without replacing the worker or its implementation. +const messages: { type: string; at: number; end?: number }[] = [] +const listening = new WeakSet() +const pending = new Map() +const postMessage = Worker.prototype.postMessage +Worker.prototype.postMessage = function (message: WorkerRequest, options?: Transferable[] | StructuredSerializeOptions) { + if (!listening.has(this)) { + listening.add(this) + this.addEventListener("message", (event: MessageEvent) => { + const item = pending.get(event.data.id) + if (item) item.end = performance.now() + pending.delete(event.data.id) + }, { capture: true }) + } + const item = { type: message.type, at: performance.now() } + messages.push(item) + pending.set(message.id, item) + postMessage.call(this, message, Array.isArray(options) ? { transfer: options } : options) +} + +function source(count: number, revision: number) { + return Array.from({ length: count }, (_, index) => { + const status = index % 10 === 0 ? 200 + revision : 200 + return `export async function route${index}(request: Request, context: RouteContext) { + const account = await context.accounts.find(request.headers.get("account-id")) + if (!account) return new Response("Account not found", { status: 404 }) + const payload = await request.json() + const record = await context.records.save({ + accountId: account.id, + category: "route-${index}", + title: payload.title.trim(), + enabled: payload.enabled ?? true, + }) + return Response.json({ id: record.id, status: ${status} }) +} +` + }).join("\n") +} + +const large = new URLSearchParams(location.search).has("large") +const before = source(large ? 1200 : 120, 0) +const inputs = [1, 2].map((revision) => { + const after = source(large ? 1200 : 120, revision) + return { file: "routes.ts", patch: createPatch("routes.ts", before, after, "", "", { context: Infinity }), after } +}) +const host = document.getElementById("root")! +let dispose: VoidFunction | undefined +let active: ReturnType | undefined + +document.head.insertAdjacentHTML("beforeend", ``) + +type Measurement = { + readyMs: number + firstReadyMs: number + workerRequests: number + workerRoundTripMs: number + cacheSize: number + syntaxSpans: number + options: RenderDiffOptions +} + +async function mount(revision: number) { + if (dispose) throw new Error("Unmount the previous viewer first") + const input = inputs[revision - 1] + const offset = messages.length + const start = performance.now() + active = normalize({ ...input, additions: large ? 120 : 12, deletions: large ? 120 : 12 }) + const pool = getWorkerPool(large ? "none" : "word-alt")! + let firstReady = 0 + let rendered = 0 + let finish!: (value: Measurement) => void + const result = new Promise((resolve) => (finish = resolve)) + const check = () => { + const stats = pool.getStats() + if (!firstReady || !rendered || stats.managerState !== "initialized" || stats.activeTasks || stats.queuedTasks || stats.busyWorkers) return + const work = messages.slice(offset).filter((item) => item.type === "diff") + if (work.some((item) => !item.end || rendered < item.end)) return + const root = host.querySelector("diffs-container")?.shadowRoot + const edit = root?.querySelector('[data-line="11"][data-line-type="change-addition"]') + if (!root || !edit?.textContent?.includes(`status: ${200 + revision}`)) return + const range = document.createRange() + range.selectNodeContents(edit) + const bounds = range.getBoundingClientRect() + if (bounds.top < host.getBoundingClientRect().top || bounds.bottom > host.getBoundingClientRect().bottom) return + finish({ + readyMs: performance.now() - start, + firstReadyMs: firstReady - start, + workerRequests: work.length, + workerRoundTripMs: work.reduce((sum, item) => sum + item.end! - item.at, 0), + cacheSize: stats.diffCacheSize, + syntaxSpans: root.querySelectorAll('[data-line] [style*="--syntax-"]').length, + options: pool.getDiffRenderOptions(), + }) + } + const unsubscribe = pool.subscribeToStatChanges(check) + // Production surfaces place a header or earlier content above the diff inside a `[role="log"]` scroll content + // element. An empty diff element at scroll offset 0 makes Pierre's virtualizer anchor its bottom edge and scroll + // the host by the full content height once the first rows render. + dispose = render(() =>
+
{input.file}
+ { firstReady ||= performance.now(); check() }} + onPostRender={(_, __, phase) => { + if (phase === "unmount") return + rendered = performance.now() + queueMicrotask(check) + }} /> +
, host) + const value = await result + unsubscribe() + return value +} + +export const highlighting = { + mount, + configure(options: Partial) { return getWorkerPool(large ? "none" : "word-alt")!.setRenderOptions(options) }, + unmount() { dispose?.(); dispose = undefined; host.scrollTop = 0 }, + contents() { return active && { before: text(active, "deletions"), after: text(active, "additions") } }, + input: { before, after: inputs.map((input) => input.after) }, + dimensions: { + functions: large ? 1200 : 120, + beforeBytes: new TextEncoder().encode(before).length, + afterBytes: new TextEncoder().encode(inputs[0].after).length, + patchBytes: new TextEncoder().encode(inputs[0].patch).length, + lines: before.split("\n").length - 1, + }, +} + +declare global { interface Window { highlighting: typeof highlighting } } +window.highlighting = highlighting diff --git a/packages/session-ui/src/components/session-diff.test.ts b/packages/session-ui/src/components/session-diff.test.ts index 8272c5afb49..893621797e3 100644 --- a/packages/session-ui/src/components/session-diff.test.ts +++ b/packages/session-ui/src/components/session-diff.test.ts @@ -127,6 +127,38 @@ describe("session diff", () => { expect(resolveFileDiff({ file: "b.ts", patch }).name).toBe("b.ts") }) + test.each([ + "@@ -1 +1 @@\n-old\n+new\n", + "--- a.ts\t\n+++ a.ts\t\n@@ -1 +1 @@\n-old\n+new\n", + ])("reuses a highlight identity for the same cached patch: %s", (patch) => { + const first = resolveFileDiff({ file: "a.ts", patch }) + expect(first.cacheKey).toBeString() + expect(resolveFileDiff({ file: "a.ts", patch }).cacheKey).toBe(first.cacheKey) + expect(resolveFileDiff({ file: "b.ts", patch }).cacheKey).not.toBe(first.cacheKey) + expect(resolveFileDiff({ file: "a.ts", patch: patch.replace("+new", "+next") }).cacheKey).not.toBe(first.cacheKey) + }) + + test("keys preloaded content diffs by file name and content", () => { + const diff = { file: "a.ts", before: "one\n", after: "two\n", additions: 1, deletions: 1 } + const first = normalize(diff).fileDiff + expect(first.cacheKey).toBeString() + expect(normalize(diff).fileDiff.cacheKey).toBe(first.cacheKey) + expect(normalize({ ...diff, file: "a.py" }).fileDiff.cacheKey).not.toBe(first.cacheKey) + expect(normalize({ ...diff, after: "three\n" }).fileDiff.cacheKey).not.toBe(first.cacheKey) + }) + + test("does not reuse an evicted highlight identity for different content", () => { + const patch = "@@ -1 +1 @@\n-old\n+new\n" + const first = resolveFileDiff({ file: "evicted.ts", patch }) + const keys = Array.from({ length: 20 }, (_, index) => + resolveFileDiff({ file: "evicted.ts", patch: patch.replace("+new", `+new${index}`) }).cacheKey, + ) + expect(keys).not.toContain(first.cacheKey) + const restored = resolveFileDiff({ file: "evicted.ts", patch }) + expect(restored.additionLines).toEqual(first.additionLines) + expect(restored.cacheKey).toBeString() + }) + test("keeps capped header-only patches partial", () => { const fileDiff = resolveFileDiff({ file: "a.ts", diff --git a/packages/session-ui/src/components/session-diff.ts b/packages/session-ui/src/components/session-diff.ts index ea89ac9625d..96cf1e062fc 100644 --- a/packages/session-ui/src/components/session-diff.ts +++ b/packages/session-ui/src/components/session-diff.ts @@ -1,5 +1,6 @@ import { parseDiffFromFile, parsePatchFiles, type FileDiffMetadata } from "@pierre/diffs" import { parsePatch } from "diff" +import { checksum } from "@opencode-ai/util/encode" import type { FileDiffInfo } from "@opencode-ai/client/promise" import type { PresentationFileDiff } from "../file-presentation" @@ -65,6 +66,8 @@ function fileDiffFromPatch(file: string, patch: string) { const value = contents ? fileDiffFromContent(file, contents.before, contents.after) : ((input ? parsePatchFiles(input)[0]?.files[0] : undefined) ?? emptyFileDiff(file)) + // Complete patches already carry a content key from fileDiffFromContent; partial patches are keyed by the patch text. + value.cacheKey ??= highlightKey(key) patchFileDiffCache.set(key, value) while (patchFileDiffCache.size > diffCacheLimit) patchFileDiffCache.delete(patchFileDiffCache.keys().next().value!) return value @@ -136,7 +139,16 @@ function patchInput(file: string, patch: string) { function fileDiffFromContent(file: string, before: string, after: string) { if (!before && !after) return emptyFileDiff(file) - return parseDiffFromFile({ name: file, contents: before }, { name: file, contents: after }) + const value = parseDiffFromFile({ name: file, contents: before }, { name: file, contents: after }) + value.cacheKey = highlightKey(`${file}\0${before}\0${after}`) + return value +} + +// Pierre reuses and dedups worker highlighting only for diffs that carry a cacheKey, and it treats diffs with equal +// keys as the same target. Derive the key from every input that shapes the highlighted output: the file name selects +// the language and the content selects the lines. +function highlightKey(value: string) { + return `${value.length}:${checksum(value) ?? 0}` } function emptyFileDiff(file: string) {