From 892942508ad290dac05ef372f7d1ece023f2a2ed Mon Sep 17 00:00:00 2001 From: Yuruzuu Date: Tue, 27 Oct 2026 00:30:28 +0800 Subject: [PATCH 1/6] perf(web): reopening Changes on a large diff no longer stalls its animation Co-Authored-By: Claude Opus 5.5 --- apps/web/src/components/RightPanelTabs.tsx | 1 - .../src/components/diffs/parsePatch.worker.ts | 12 ++ .../parsePatchOffMainThread.browser.test.ts | 31 +++++ .../diffs/parsePatchOffMainThread.ts | 41 ++++++ .../useReviewFilePatches.browser.test.tsx | 130 ++++++++++++++++++ .../components/diffs/useReviewFilePatches.ts | 44 +++--- 6 files changed, 241 insertions(+), 18 deletions(-) create mode 100644 apps/web/src/components/diffs/parsePatch.worker.ts create mode 100644 apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts create mode 100644 apps/web/src/components/diffs/parsePatchOffMainThread.ts create mode 100644 apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx diff --git a/apps/web/src/components/RightPanelTabs.tsx b/apps/web/src/components/RightPanelTabs.tsx index 4cab22ef83871..7e8e579b0f3a2 100644 --- a/apps/web/src/components/RightPanelTabs.tsx +++ b/apps/web/src/components/RightPanelTabs.tsx @@ -1211,7 +1211,6 @@ export function RightPanelTabs(props: RightPanelTabsProps) { const stopObserving = observeResize(content ? [viewport, content] : viewport, update); viewport.addEventListener("scroll", update, { passive: true }); viewport.addEventListener("wheel", handleWheel, { passive: false }); - update(); return () => { tabListRef.current = null; diff --git a/apps/web/src/components/diffs/parsePatch.worker.ts b/apps/web/src/components/diffs/parsePatch.worker.ts new file mode 100644 index 0000000000000..2b4dead630acf --- /dev/null +++ b/apps/web/src/components/diffs/parsePatch.worker.ts @@ -0,0 +1,12 @@ +import { getRenderablePatch } from "~/lib/diffRendering"; + +self.addEventListener( + "message", + (event: MessageEvent<{ id: number; patch: string; scope: string }>) => { + const { id, patch, scope } = event.data; + self.postMessage( + { id, patch: getRenderablePatch(patch, scope, { compactPartialHunkOffsets: true }) }, + { transfer: [] }, + ); + }, +); diff --git a/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts b/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts new file mode 100644 index 0000000000000..0833d53f2ccc8 --- /dev/null +++ b/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts @@ -0,0 +1,31 @@ +import { expect, it } from "vite-plus/test"; + +import { getRenderablePatch } from "~/lib/diffRendering"; +import { parsePatchOffMainThread } from "./parsePatchOffMainThread"; + +it("parses in the worker exactly as on the main thread", async () => { + const patch = [ + "diff --git a/a.ts b/a.ts", + "--- a/a.ts", + "+++ b/a.ts", + "@@ -1,2 +1,2 @@", + " keep", + "-old", + "+new", + "diff --git a/b.ts b/b.ts", + "new file mode 100644", + "--- /dev/null", + "+++ b/b.ts", + "@@ -0,0 +1 @@", + "+added", + "", + ].join("\n"); + + const [first, second] = await Promise.all([ + parsePatchOffMainThread(patch, "test"), + parsePatchOffMainThread("", "test"), + ]); + + expect(first).toEqual(getRenderablePatch(patch, "test", { compactPartialHunkOffsets: true })); + expect(second).toBeNull(); +}); diff --git a/apps/web/src/components/diffs/parsePatchOffMainThread.ts b/apps/web/src/components/diffs/parsePatchOffMainThread.ts new file mode 100644 index 0000000000000..bb06d1a78b439 --- /dev/null +++ b/apps/web/src/components/diffs/parsePatchOffMainThread.ts @@ -0,0 +1,41 @@ +import type { RenderablePatch } from "~/lib/diffRendering"; + +// Parsing a large patch takes tens of milliseconds, mostly in @pierre/diffs copying every line, +// and the diff panel parses while its open and close transitions run. Copying the parsed +// result back from a worker costs well under a millisecond. +let worker: Worker | null = null; +let nextId = 0; +const pending = new Map< + number, + { resolve: (patch: RenderablePatch | null) => void; reject: (error: Error) => void } +>(); + +function parserWorker() { + if (worker) return worker; + const created = new Worker(new URL("./parsePatch.worker.ts", import.meta.url), { + type: "module", + }); + created.addEventListener( + "message", + (event: MessageEvent<{ id: number; patch: RenderablePatch | null }>) => { + pending.get(event.data.id)?.resolve(event.data.patch); + pending.delete(event.data.id); + }, + ); + created.addEventListener("error", () => { + for (const request of pending.values()) request.reject(new Error("Could not parse the diff.")); + pending.clear(); + created.terminate(); + worker = null; + }); + worker = created; + return created; +} + +export function parsePatchOffMainThread(patch: string, scope: string) { + return new Promise((resolve, reject) => { + const id = nextId++; + pending.set(id, { resolve, reject }); + parserWorker().postMessage({ id, patch, scope }, { transfer: [] }); + }); +} diff --git a/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx b/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx new file mode 100644 index 0000000000000..8a72134387b9d --- /dev/null +++ b/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx @@ -0,0 +1,130 @@ +import { RegistryContext } from "@effect/atom-react"; +import { EnvironmentId, type ReviewDiffPreviewSource } from "@t3tools/contracts"; +import { AsyncResult, AtomRegistry } from "effect/reactivity"; +import { expect, it, vi } from "vite-plus/test"; + +import { render } from "../../../test/render"; +import { resolveFileDiffPath } from "~/lib/diffRendering"; + +const mocks = vi.hoisted(() => ({ requests: [] as string[], parses: [] as string[] })); + +const patchQuery = await vi.hoisted(async () => { + const { AsyncResult, Atom } = await import("effect/reactivity"); + return Atom.family((path: string) => + Atom.writable( + (get) => { + mocks.requests.push(path); + return AsyncResult.waitingFrom( + get.self>(), + ); + }, + (get, value: AsyncResult.AsyncResult) => get.setSelf(value), + ).pipe(Atom.setIdleTTL(5 * 60_000)), + ); +}); + +vi.mock("~/state/review", () => ({ + reviewEnvironment: { + diffFilePatch: (target: { input: { request: { file: { path: string } } } }) => + patchQuery(target.input.request.file.path), + }, +})); + +vi.mock("./parsePatchOffMainThread", async () => { + const { getRenderablePatch } = await import("~/lib/diffRendering"); + return { + parsePatchOffMainThread: async (patch: string, scope: string) => { + mocks.parses.push(patch); + return getRenderablePatch(patch, scope, { compactPartialHunkOffsets: true }); + }, + }; +}); + +import { useReviewFilePatches } from "./useReviewFilePatches"; + +const source: ReviewDiffPreviewSource = { + id: "working-tree", + kind: "working-tree", + title: "Uncommitted", + baseRef: null, + headRef: null, + diff: "preview", + diffHash: "hash", + truncated: true, + files: [{ path: "a.ts", previousPath: null, additions: 1, deletions: 0 }], +}; + +type HookResult = ReturnType; + +function Harness(props: { revision: string; onResult: (result: HookResult) => void }) { + const result = useReviewFilePatches({ + environmentId: EnvironmentId.make("test"), + cwd: "/repo", + source, + baseRef: null, + ignoreWhitespace: false, + theme: "dark", + revision: props.revision, + preview: null, + }); + props.onResult(result); + return ( +
    + {result.renderableFiles.map((file) => ( +
  • + {resolveFileDiffPath(file)} {file.additionLines.join(",") || "pending"} +
  • + ))} +
+ ); +} + +function setup() { + mocks.requests = []; + mocks.parses = []; + const registry = AtomRegistry.make(); + const results: HookResult[] = []; + return { + ui: (revision = "first") => ( + + results.push(result)} /> + + ), + latest: () => results.at(-1)!, + complete(contents: string) { + registry.set( + patchQuery("a.ts"), + AsyncResult.success({ + ...source, + diff: `diff --git a/a.ts b/a.ts\nnew file mode 100644\n--- /dev/null\n+++ b/a.ts\n@@ -0,0 +1 @@\n+${contents}\n`, + truncated: false, + }), + ); + }, + }; +} + +it("reopening shows the kept parse and revalidates once the preview refreshes", async () => { + const h = setup(); + { + await using screen = await render(h.ui(), { router: false }); + h.complete("first"); + await expect.element(screen.getByText("a.ts first")).toBeInTheDocument(); + } + const parsed = h.latest().renderableFiles[0]; + await using screen = await render(h.ui(), { router: false }); + expect(h.latest().renderableFiles[0]).toBe(parsed); + expect(mocks.requests).toEqual(["a.ts"]); + + await screen.rerender(h.ui("refreshed")); + expect(mocks.requests).toEqual(["a.ts", "a.ts"]); + h.complete("first"); + await vi.waitFor(() => expect(h.latest().isPending).toBe(false)); + expect(h.latest().renderableFiles[0]).toBe(parsed); + expect(mocks.parses).toHaveLength(1); + + await screen.rerender(h.ui("changed")); + h.complete("changed"); + await expect.element(screen.getByText("a.ts changed")).toBeInTheDocument(); + expect(mocks.parses).toHaveLength(2); +}); diff --git a/apps/web/src/components/diffs/useReviewFilePatches.ts b/apps/web/src/components/diffs/useReviewFilePatches.ts index e7fbfc4116f5c..c300825ed2c08 100644 --- a/apps/web/src/components/diffs/useReviewFilePatches.ts +++ b/apps/web/src/components/diffs/useReviewFilePatches.ts @@ -3,10 +3,13 @@ import type { FileDiffMetadata } from "@pierre/diffs"; import type { EnvironmentId, ReviewDiffPreviewSource } from "@t3tools/contracts"; import * as AsyncResult from "effect/reactivity/AsyncResult"; import * as Atom from "effect/reactivity/Atom"; +import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; import { useContext, useEffect, useRef, useState } from "react"; import { useStableCallback } from "~/hooks/useStableCallback"; -import { getRenderablePatch, resolveFileDiffPath, type RenderablePatch } from "~/lib/diffRendering"; +import { resolveFileDiffPath, type RenderablePatch } from "~/lib/diffRendering"; import { reviewEnvironment } from "~/state/review"; +import { parsePatchOffMainThread } from "./parsePatchOffMainThread"; const filePathCollator = new Intl.Collator(undefined, { numeric: true, @@ -55,19 +58,17 @@ export function useReviewFilePatches({ const queriedPatchesAtom = reviewPatchesAtom( JSON.stringify([theme, queries.map(({ index, target }) => [index, target])]), ); - const previousPreview = useRef({ scope, revision, queries: [] as typeof queries }); + // Opening the panel refreshes the preview, and its new revision revalidates the cached files. + // Refreshing them on mount as well would request and decode every patch twice. + const previousRevision = useRef(revision); useEffect(() => { - const previous = previousPreview.current; - previousPreview.current = { scope, revision, queries }; + if (previousRevision.current === revision) return; + previousRevision.current = revision; for (const { query } of queries) { - const changed = previous.scope === scope && previous.revision !== revision; - const cached = - !previous.queries.some((entry) => entry.query === query) && - registry.get(query)._tag !== "Initial" && - !registry.get(query).waiting; - if (changed || cached) registry.refresh(query); + const result = registry.get(query); + if (result._tag !== "Initial" && !result.waiting) registry.refresh(query); } - }, [scope, revision, queries, registry]); + }, [revision, queries, registry]); const patches = useAtomValue(queriedPatchesAtom); const retry = useStableCallback((path: string) => { const files = sortedReviewFiles(source); @@ -217,13 +218,22 @@ function sortedReviewFiles(source: ReviewDiffPreviewSource | null) { type ReviewPatchTarget = Parameters[0]; +type ParsedPatch = { source: ReviewDiffPreviewSource; patch: RenderablePatch | null }; + +// Parses outlive the panel like their source queries, and a revalidation that returns the same +// text keeps the previous parse, so reopening the panel parses nothing. const parsedPatchAtom = Atom.family((key: string) => { const [theme, target] = JSON.parse(key) as ["light" | "dark", ReviewPatchTarget]; - return Atom.map(reviewEnvironment.diffFilePatch(target), (result) => - AsyncResult.map(result, (source) => { - let patch = getRenderablePatch(source.diff, `diff-panel:${theme}`, { - compactPartialHunkOffsets: true, - }); + return Atom.make((get) => + Effect.gen(function* () { + const source = yield* get.result(reviewEnvironment.diffFilePatch(target)); + const previous = Option.getOrUndefined( + Option.flatMap(get.self>(), AsyncResult.value), + ); + if (previous?.source.diff === source.diff) return { source, patch: previous.patch }; + let patch = yield* Effect.promise(() => + parsePatchOffMainThread(source.diff, `diff-panel:${theme}`), + ); if (patch?.kind === "files" && patch.files.length === 1 && source.files?.length === 1) { const stat = source.files[0]!; const file = { ...patch.files[0]!, name: stat.path }; @@ -233,7 +243,7 @@ const parsedPatchAtom = Atom.family((key: string) => { } return { source, patch }; }), - ); + ).pipe(Atom.setIdleTTL(5 * 60_000)); }); const reviewPatchesAtom = Atom.family((key: string) => { From 67b188f0b9119ec80c7b1c86f7bd9c2e681aa8bb Mon Sep 17 00:00:00 2001 From: Yuruzuu Date: Tue, 27 Oct 2026 00:59:40 +0800 Subject: [PATCH 2/6] fix(web): later Changes files revalidate and refreshes stay pending Files requested after the preview refresh now revalidate once under the new revision, and a revalidation keeps the previous parse while showing the refresh as pending. Co-Authored-By: Claude Opus 5.5 --- .../useReviewFilePatches.browser.test.tsx | 79 +++++++++++++------ .../components/diffs/useReviewFilePatches.ts | 21 +++-- 2 files changed, 71 insertions(+), 29 deletions(-) diff --git a/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx b/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx index 8a72134387b9d..ae998e102c7b2 100644 --- a/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx +++ b/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx @@ -42,25 +42,31 @@ vi.mock("./parsePatchOffMainThread", async () => { import { useReviewFilePatches } from "./useReviewFilePatches"; -const source: ReviewDiffPreviewSource = { - id: "working-tree", - kind: "working-tree", - title: "Uncommitted", - baseRef: null, - headRef: null, - diff: "preview", - diffHash: "hash", - truncated: true, - files: [{ path: "a.ts", previousPath: null, additions: 1, deletions: 0 }], -}; +function previewSource(paths: string[]): ReviewDiffPreviewSource { + return { + id: "working-tree", + kind: "working-tree", + title: "Uncommitted", + baseRef: null, + headRef: null, + diff: "preview", + diffHash: "hash", + truncated: true, + files: paths.map((path) => ({ path, previousPath: null, additions: 1, deletions: 0 })), + }; +} type HookResult = ReturnType; -function Harness(props: { revision: string; onResult: (result: HookResult) => void }) { +function Harness(props: { + source: ReviewDiffPreviewSource; + revision: string; + onResult: (result: HookResult) => void; +}) { const result = useReviewFilePatches({ environmentId: EnvironmentId.make("test"), cwd: "/repo", - source, + source: props.source, baseRef: null, ignoreWhitespace: false, theme: "dark", @@ -79,24 +85,32 @@ function Harness(props: { revision: string; onResult: (result: HookResult) => vo ); } -function setup() { +function setup(paths = ["a.ts"]) { mocks.requests = []; mocks.parses = []; const registry = AtomRegistry.make(); + const source = previewSource(paths); const results: HookResult[] = []; return { ui: (revision = "first") => ( - results.push(result)} /> + results.push(result)} /> ), latest: () => results.at(-1)!, - complete(contents: string) { + requestsFor: (path: string) => mocks.requests.filter((request) => request === path).length, + complete(path: string, contents: string) { registry.set( - patchQuery("a.ts"), + patchQuery(path), AsyncResult.success({ ...source, - diff: `diff --git a/a.ts b/a.ts\nnew file mode 100644\n--- /dev/null\n+++ b/a.ts\n@@ -0,0 +1 @@\n+${contents}\n`, + diff: `diff --git a/${path} b/${path} +new file mode 100644 +--- /dev/null ++++ b/${path} +@@ -0,0 +1 @@ ++${contents} +`, truncated: false, }), ); @@ -107,24 +121,43 @@ function setup() { it("reopening shows the kept parse and revalidates once the preview refreshes", async () => { const h = setup(); { - await using screen = await render(h.ui(), { router: false }); - h.complete("first"); + await using screen = await render(h.ui()); + h.complete("a.ts", "first"); await expect.element(screen.getByText("a.ts first")).toBeInTheDocument(); } const parsed = h.latest().renderableFiles[0]; - await using screen = await render(h.ui(), { router: false }); + await using screen = await render(h.ui()); expect(h.latest().renderableFiles[0]).toBe(parsed); expect(mocks.requests).toEqual(["a.ts"]); await screen.rerender(h.ui("refreshed")); expect(mocks.requests).toEqual(["a.ts", "a.ts"]); - h.complete("first"); + await vi.waitFor(() => expect(h.latest().isPending).toBe(true)); + expect(h.latest().renderableFiles[0]).toBe(parsed); + h.complete("a.ts", "first"); await vi.waitFor(() => expect(h.latest().isPending).toBe(false)); expect(h.latest().renderableFiles[0]).toBe(parsed); expect(mocks.parses).toHaveLength(1); await screen.rerender(h.ui("changed")); - h.complete("changed"); + h.complete("a.ts", "changed"); await expect.element(screen.getByText("a.ts changed")).toBeInTheDocument(); expect(mocks.parses).toHaveLength(2); }); + +it("revalidates a cached file requested after the preview refreshes", async () => { + const h = setup(["a.ts", "b.ts", "c.ts", "d.ts", "e.ts"]); + { + await using screen = await render(h.ui()); + h.latest().requestFile(4); + await vi.waitFor(() => expect(h.requestsFor("e.ts")).toBe(1)); + h.complete("e.ts", "first"); + await expect.element(screen.getByText("e.ts first")).toBeInTheDocument(); + } + await using screen = await render(h.ui()); + await screen.rerender(h.ui("refreshed")); + h.latest().requestFile(4); + await vi.waitFor(() => expect(h.requestsFor("e.ts")).toBe(2)); + await screen.rerender(h.ui("refreshed")); + expect(h.requestsFor("e.ts")).toBe(2); +}); diff --git a/apps/web/src/components/diffs/useReviewFilePatches.ts b/apps/web/src/components/diffs/useReviewFilePatches.ts index c300825ed2c08..38864e1e3a064 100644 --- a/apps/web/src/components/diffs/useReviewFilePatches.ts +++ b/apps/web/src/components/diffs/useReviewFilePatches.ts @@ -58,13 +58,19 @@ export function useReviewFilePatches({ const queriedPatchesAtom = reviewPatchesAtom( JSON.stringify([theme, queries.map(({ index, target }) => [index, target])]), ); - // Opening the panel refreshes the preview, and its new revision revalidates the cached files. - // Refreshing them on mount as well would request and decode every patch twice. - const previousRevision = useRef(revision); + // Opening the panel refreshes the preview. Under its new revision, each cached file revalidates + // once, including files requested later. Refreshing them on mount as well would request and + // decode every patch twice. + const revalidated = useRef({ revision, queries: null as Set | null }); useEffect(() => { - if (previousRevision.current === revision) return; - previousRevision.current = revision; + if (revalidated.current.revision !== revision) { + revalidated.current = { revision, queries: new Set() }; + } + const seen = revalidated.current.queries; + if (!seen) return; for (const { query } of queries) { + if (seen.has(query)) continue; + seen.add(query); const result = registry.get(query); if (result._tag !== "Initial" && !result.waiting) registry.refresh(query); } @@ -226,7 +232,10 @@ const parsedPatchAtom = Atom.family((key: string) => { const [theme, target] = JSON.parse(key) as ["light" | "dark", ReviewPatchTarget]; return Atom.make((get) => Effect.gen(function* () { - const source = yield* get.result(reviewEnvironment.diffFilePatch(target)); + // Waiting out a revalidation keeps the previous parse visible and the refresh pending. + const source = yield* get.result(reviewEnvironment.diffFilePatch(target), { + suspendOnWaiting: true, + }); const previous = Option.getOrUndefined( Option.flatMap(get.self>(), AsyncResult.value), ); From 92dfa8e450684828dc0e872da19739249e4563d0 Mon Sep 17 00:00:00 2001 From: Yuruzuu Date: Tue, 27 Oct 2026 01:14:00 +0800 Subject: [PATCH 3/6] fix(web): Changes restarts file loads that predate a refreshed preview Co-Authored-By: Claude Opus 5.5 --- .../diffs/useReviewFilePatches.browser.test.tsx | 4 ++++ apps/web/src/components/diffs/useReviewFilePatches.ts | 9 +++++---- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx b/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx index ae998e102c7b2..536eb51d6e303 100644 --- a/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx +++ b/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx @@ -160,4 +160,8 @@ it("revalidates a cached file requested after the preview refreshes", async () = await vi.waitFor(() => expect(h.requestsFor("e.ts")).toBe(2)); await screen.rerender(h.ui("refreshed")); expect(h.requestsFor("e.ts")).toBe(2); + + // e.ts is still loading from the previous revision, so the next refresh restarts it. + await screen.rerender(h.ui("focused")); + expect(h.requestsFor("e.ts")).toBe(3); }); diff --git a/apps/web/src/components/diffs/useReviewFilePatches.ts b/apps/web/src/components/diffs/useReviewFilePatches.ts index 38864e1e3a064..98da77331bd3a 100644 --- a/apps/web/src/components/diffs/useReviewFilePatches.ts +++ b/apps/web/src/components/diffs/useReviewFilePatches.ts @@ -63,16 +63,17 @@ export function useReviewFilePatches({ // decode every patch twice. const revalidated = useRef({ revision, queries: null as Set | null }); useEffect(() => { - if (revalidated.current.revision !== revision) { - revalidated.current = { revision, queries: new Set() }; - } + const previous = revalidated.current; + if (previous.revision !== revision) revalidated.current = { revision, queries: new Set() }; const seen = revalidated.current.queries; if (!seen) return; for (const { query } of queries) { if (seen.has(query)) continue; seen.add(query); const result = registry.get(query); - if (result._tag !== "Initial" && !result.waiting) registry.refresh(query); + // A request still running from the previous revision may predate the refreshed preview. + const stale = previous.queries?.has(query) || (result._tag !== "Initial" && !result.waiting); + if (stale) registry.refresh(query); } }, [revision, queries, registry]); const patches = useAtomValue(queriedPatchesAtom); From ce54042c404546f2ce2ded8a4688348999eb261d Mon Sep 17 00:00:00 2001 From: maria-rcks Date: Tue, 27 Oct 2026 02:51:40 +0000 Subject: [PATCH 4/6] fix(web): preserve diff refresh lifecycle while caching parses --- apps/web/src/components/RightPanelTabs.tsx | 1 + .../diffs/parsePatchOffMainThread.ts | 3 --- .../useReviewFilePatches.browser.test.tsx | 19 +++++++++++--- .../components/diffs/useReviewFilePatches.ts | 25 ++++++++----------- 4 files changed, 27 insertions(+), 21 deletions(-) diff --git a/apps/web/src/components/RightPanelTabs.tsx b/apps/web/src/components/RightPanelTabs.tsx index 7e8e579b0f3a2..4cab22ef83871 100644 --- a/apps/web/src/components/RightPanelTabs.tsx +++ b/apps/web/src/components/RightPanelTabs.tsx @@ -1211,6 +1211,7 @@ export function RightPanelTabs(props: RightPanelTabsProps) { const stopObserving = observeResize(content ? [viewport, content] : viewport, update); viewport.addEventListener("scroll", update, { passive: true }); viewport.addEventListener("wheel", handleWheel, { passive: false }); + update(); return () => { tabListRef.current = null; diff --git a/apps/web/src/components/diffs/parsePatchOffMainThread.ts b/apps/web/src/components/diffs/parsePatchOffMainThread.ts index bb06d1a78b439..40f135d4d5cd9 100644 --- a/apps/web/src/components/diffs/parsePatchOffMainThread.ts +++ b/apps/web/src/components/diffs/parsePatchOffMainThread.ts @@ -1,8 +1,5 @@ import type { RenderablePatch } from "~/lib/diffRendering"; -// Parsing a large patch takes tens of milliseconds, mostly in @pierre/diffs copying every line, -// and the diff panel parses while its open and close transitions run. Copying the parsed -// result back from a worker costs well under a millisecond. let worker: Worker | null = null; let nextId = 0; const pending = new Map< diff --git a/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx b/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx index 536eb51d6e303..e489c4e1fe7d5 100644 --- a/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx +++ b/apps/web/src/components/diffs/useReviewFilePatches.browser.test.tsx @@ -118,7 +118,7 @@ new file mode 100644 }; } -it("reopening shows the kept parse and revalidates once the preview refreshes", async () => { +it("reopening keeps the parse while mount and preview refreshes revalidate", async () => { const h = setup(); { await using screen = await render(h.ui()); @@ -128,10 +128,10 @@ it("reopening shows the kept parse and revalidates once the preview refreshes", const parsed = h.latest().renderableFiles[0]; await using screen = await render(h.ui()); expect(h.latest().renderableFiles[0]).toBe(parsed); - expect(mocks.requests).toEqual(["a.ts"]); + expect(mocks.requests).toEqual(["a.ts", "a.ts"]); await screen.rerender(h.ui("refreshed")); - expect(mocks.requests).toEqual(["a.ts", "a.ts"]); + expect(mocks.requests).toEqual(["a.ts", "a.ts", "a.ts"]); await vi.waitFor(() => expect(h.latest().isPending).toBe(true)); expect(h.latest().renderableFiles[0]).toBe(parsed); h.complete("a.ts", "first"); @@ -165,3 +165,16 @@ it("revalidates a cached file requested after the preview refreshes", async () = await screen.rerender(h.ui("focused")); expect(h.requestsFor("e.ts")).toBe(3); }); + +it("restarts an in-flight file load on the first preview refresh", async () => { + const h = setup(); + await using screen = await render(h.ui()); + expect(h.requestsFor("a.ts")).toBe(1); + await screen.rerender(h.ui("refreshed")); + expect(h.requestsFor("a.ts")).toBe(2); + await screen.rerender(h.ui("refreshed")); + expect(h.requestsFor("a.ts")).toBe(2); + h.complete("a.ts", "fresh"); + await expect.element(screen.getByText("a.ts fresh")).toBeInTheDocument(); + await vi.waitFor(() => expect(h.latest().isPending).toBe(false)); +}); diff --git a/apps/web/src/components/diffs/useReviewFilePatches.ts b/apps/web/src/components/diffs/useReviewFilePatches.ts index 98da77331bd3a..40ac2ec97b6c5 100644 --- a/apps/web/src/components/diffs/useReviewFilePatches.ts +++ b/apps/web/src/components/diffs/useReviewFilePatches.ts @@ -58,24 +58,19 @@ export function useReviewFilePatches({ const queriedPatchesAtom = reviewPatchesAtom( JSON.stringify([theme, queries.map(({ index, target }) => [index, target])]), ); - // Opening the panel refreshes the preview. Under its new revision, each cached file revalidates - // once, including files requested later. Refreshing them on mount as well would request and - // decode every patch twice. - const revalidated = useRef({ revision, queries: null as Set | null }); + const previousPreview = useRef({ scope, revision, queries: [] as typeof queries }); useEffect(() => { - const previous = revalidated.current; - if (previous.revision !== revision) revalidated.current = { revision, queries: new Set() }; - const seen = revalidated.current.queries; - if (!seen) return; + const previous = previousPreview.current; + previousPreview.current = { scope, revision, queries }; for (const { query } of queries) { - if (seen.has(query)) continue; - seen.add(query); - const result = registry.get(query); - // A request still running from the previous revision may predate the refreshed preview. - const stale = previous.queries?.has(query) || (result._tag !== "Initial" && !result.waiting); - if (stale) registry.refresh(query); + const changed = previous.scope === scope && previous.revision !== revision; + const cached = + !previous.queries.some((entry) => entry.query === query) && + registry.get(query)._tag !== "Initial" && + !registry.get(query).waiting; + if (changed || cached) registry.refresh(query); } - }, [revision, queries, registry]); + }, [scope, revision, queries, registry]); const patches = useAtomValue(queriedPatchesAtom); const retry = useStableCallback((path: string) => { const files = sortedReviewFiles(source); From db935efbf10bcf3c154bf3528880ae28e0b69d62 Mon Sep 17 00:00:00 2001 From: Yuruzuu Date: Tue, 3 Nov 2026 04:14:41 +0800 Subject: [PATCH 5/6] fix(web): diffs parse on the main thread when the worker fails Co-Authored-By: Claude Opus 5.5 --- .../parsePatchOffMainThread.browser.test.ts | 82 ++++++++++++++----- .../diffs/parsePatchOffMainThread.ts | 31 ++++--- 2 files changed, 82 insertions(+), 31 deletions(-) diff --git a/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts b/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts index 0833d53f2ccc8..e5f8065d98a37 100644 --- a/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts +++ b/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts @@ -1,31 +1,73 @@ -import { expect, it } from "vite-plus/test"; +import { expect, it, vi } from "vite-plus/test"; import { getRenderablePatch } from "~/lib/diffRendering"; import { parsePatchOffMainThread } from "./parsePatchOffMainThread"; -it("parses in the worker exactly as on the main thread", async () => { - const patch = [ - "diff --git a/a.ts b/a.ts", - "--- a/a.ts", - "+++ b/a.ts", - "@@ -1,2 +1,2 @@", - " keep", - "-old", - "+new", - "diff --git a/b.ts b/b.ts", - "new file mode 100644", - "--- /dev/null", - "+++ b/b.ts", - "@@ -0,0 +1 @@", - "+added", - "", - ].join("\n"); +const PATCH = [ + "diff --git a/a.ts b/a.ts", + "--- a/a.ts", + "+++ b/a.ts", + "@@ -1,2 +1,2 @@", + " keep", + "-old", + "+new", + "diff --git a/b.ts b/b.ts", + "new file mode 100644", + "--- /dev/null", + "+++ b/b.ts", + "@@ -0,0 +1 @@", + "+added", + "", +].join("\n"); + +// These run first: the module keeps a working worker, and browser mode cannot reset modules. +it.each([ + { + name: "the worker cannot be created", + FailingWorker: function () { + throw new Error("blocked"); + }, + }, + { + name: "posting to the worker throws", + FailingWorker: class extends EventTarget { + postMessage() { + throw new Error("could not post"); + } + terminate() {} + }, + }, + { + name: "the worker reports an error", + FailingWorker: class extends EventTarget { + postMessage() { + queueMicrotask(() => this.dispatchEvent(new Event("error"))); + } + terminate() {} + }, + }, +])("parses on the main thread when $name", async ({ FailingWorker }) => { + vi.stubGlobal("Worker", FailingWorker); + try { + await expect( + Promise.all([ + parsePatchOffMainThread(PATCH, "fallback"), + parsePatchOffMainThread(PATCH, "fallback"), + ]), + ).resolves.toEqual( + Array(2).fill(getRenderablePatch(PATCH, "fallback", { compactPartialHunkOffsets: true })), + ); + } finally { + vi.unstubAllGlobals(); + } +}); +it("parses in the worker exactly as on the main thread", async () => { const [first, second] = await Promise.all([ - parsePatchOffMainThread(patch, "test"), + parsePatchOffMainThread(PATCH, "test"), parsePatchOffMainThread("", "test"), ]); - expect(first).toEqual(getRenderablePatch(patch, "test", { compactPartialHunkOffsets: true })); + expect(first).toEqual(getRenderablePatch(PATCH, "test", { compactPartialHunkOffsets: true })); expect(second).toBeNull(); }); diff --git a/apps/web/src/components/diffs/parsePatchOffMainThread.ts b/apps/web/src/components/diffs/parsePatchOffMainThread.ts index 40f135d4d5cd9..c14d51c30d83d 100644 --- a/apps/web/src/components/diffs/parsePatchOffMainThread.ts +++ b/apps/web/src/components/diffs/parsePatchOffMainThread.ts @@ -1,12 +1,22 @@ -import type { RenderablePatch } from "~/lib/diffRendering"; +import { getRenderablePatch, type RenderablePatch } from "~/lib/diffRendering"; let worker: Worker | null = null; let nextId = 0; const pending = new Map< number, - { resolve: (patch: RenderablePatch | null) => void; reject: (error: Error) => void } + { patch: string; scope: string; resolve: (patch: RenderablePatch | null) => void } >(); +function parsePendingOnMainThread() { + const requests = [...pending.values()]; + pending.clear(); + worker?.terminate(); + worker = null; + for (const { patch, scope, resolve } of requests) { + resolve(getRenderablePatch(patch, scope, { compactPartialHunkOffsets: true })); + } +} + function parserWorker() { if (worker) return worker; const created = new Worker(new URL("./parsePatch.worker.ts", import.meta.url), { @@ -19,20 +29,19 @@ function parserWorker() { pending.delete(event.data.id); }, ); - created.addEventListener("error", () => { - for (const request of pending.values()) request.reject(new Error("Could not parse the diff.")); - pending.clear(); - created.terminate(); - worker = null; - }); + created.addEventListener("error", parsePendingOnMainThread); worker = created; return created; } export function parsePatchOffMainThread(patch: string, scope: string) { - return new Promise((resolve, reject) => { + return new Promise((resolve) => { const id = nextId++; - pending.set(id, { resolve, reject }); - parserWorker().postMessage({ id, patch, scope }, { transfer: [] }); + pending.set(id, { patch, scope, resolve }); + try { + parserWorker().postMessage({ id, patch, scope }, { transfer: [] }); + } catch { + parsePendingOnMainThread(); + } }); } From a4bece806ed1e127754f1a3877e341406ccd5f0e Mon Sep 17 00:00:00 2001 From: Yuruzuu Date: Tue, 3 Nov 2026 12:13:20 +0800 Subject: [PATCH 6/6] test(web): worker parse test checks the worker replied Co-Authored-By: Claude Opus 5.5 --- .../parsePatchOffMainThread.browser.test.ts | 29 +++++++++++++++---- 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts b/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts index e5f8065d98a37..c077f819f2eb3 100644 --- a/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts +++ b/apps/web/src/components/diffs/parsePatchOffMainThread.browser.test.ts @@ -63,11 +63,28 @@ it.each([ }); it("parses in the worker exactly as on the main thread", async () => { - const [first, second] = await Promise.all([ - parsePatchOffMainThread(PATCH, "test"), - parsePatchOffMainThread("", "test"), - ]); + const NativeWorker = globalThis.Worker; + let workerReplies = 0; + vi.stubGlobal( + "Worker", + class extends NativeWorker { + constructor(...args: ConstructorParameters) { + super(...args); + this.addEventListener("message", () => workerReplies++); + } + }, + ); + try { + const [first, second] = await Promise.all([ + parsePatchOffMainThread(PATCH, "test"), + parsePatchOffMainThread("", "test"), + ]); - expect(first).toEqual(getRenderablePatch(PATCH, "test", { compactPartialHunkOffsets: true })); - expect(second).toBeNull(); + // The fallback returns the same values, so equal output alone would not prove the worker ran. + expect(workerReplies).toBe(2); + expect(first).toEqual(getRenderablePatch(PATCH, "test", { compactPartialHunkOffsets: true })); + expect(second).toBeNull(); + } finally { + vi.unstubAllGlobals(); + } });