From 45a4bd1c1b0c063de724021cec8fdb260d9f03ca Mon Sep 17 00:00:00 2001 From: Wout Stiens <71498452+StiensWout@users.noreply.github.com> Date: Sat, 21 Nov 2026 20:18:15 +0100 Subject: [PATCH 1/6] test(web): cover navigation during Browser tab reopen Co-authored-by: GPT 6.2 Sol --- ...ning-browser-keeps-the-newer-thread.e2e.ts | 103 ++++++++++++++++++ 1 file changed, 103 insertions(+) create mode 100644 scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts diff --git a/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts b/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts new file mode 100644 index 0000000000000..d1270ef325df4 --- /dev/null +++ b/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts @@ -0,0 +1,103 @@ +/// +import { expect } from "e2e"; + +import { test, WEB } from "./t3.ts"; + +interface ReopenGate { + readonly closed: Promise; + readonly requested: Promise; + readonly arm: () => void; + readonly release: () => Promise; +} + +declare global { + interface Window { + reopenGate: ReopenGate; + } +} + +test( + "A browser tab finishing its reopen leaves the newer conversation on screen", + WEB, + async ({ t3, app, browser, screen }) => { + const project = await t3.project("demo"); + const owner = await t3.thread({ project, title: "Browser owner", messages: ["first"] }); + await t3.thread({ + project, + title: "Newer conversation", + messages: ["Stay in this conversation"], + }); + + await browser.addInitScript(() => { + const closed = Promise.withResolvers(); + const requested = Promise.withResolvers(); + const restored = Promise.withResolvers(); + let hasClosedBrowser = false; + let armed = false; + let sendHeld = () => {}; + const setItem = Storage.prototype.setItem; + Storage.prototype.setItem = function (key, value) { + setItem.call(this, key, value); + if (key !== "t3code:closed-views:v2") return; + const hasBrowser = value.includes('"kind":"browser"'); + if (hasBrowser) closed.resolve(); + else if (hasClosedBrowser) restored.resolve(); + hasClosedBrowser = hasBrowser; + }; + const send = WebSocket.prototype.send; + WebSocket.prototype.send = function (data) { + if (!armed || typeof data !== "string") return send.call(this, data); + const parsed = JSON.parse(data); + const messages = [parsed].flat(); + const isOpen = (message: { _tag?: string; tag?: string }) => + message._tag === "Request" && message.tag === "preview.open"; + const previewOpens = messages.filter(isOpen); + if (previewOpens.length === 0) return send.call(this, data); + armed = false; + const others = messages.filter((message) => !isOpen(message)); + if (others.length > 0) send.call(this, JSON.stringify(others)); + sendHeld = () => + send.call(this, Array.isArray(parsed) ? JSON.stringify(previewOpens) : data); + requested.resolve(); + }; + window.reopenGate = { + closed: closed.promise, + requested: requested.promise, + arm: () => { + armed = true; + }, + release: () => { + sendHeld(); + return restored.promise; + }, + }; + }); + + await t3.open(owner); + await screen.getByRole("button", "Toggle right panel").tap(); + await screen.getByRole("button", "Browser B").tap(); + await screen.getByRole("button", "Close Browser", { exact: true }).tap(); + await browser.evaluate(async () => { + await window.reopenGate.closed; + window.reopenGate.arm(); + return null; + }); + + await browser.keyboard.press("Control+Shift+t"); + await browser.evaluate(async () => { + await window.reopenGate.requested; + return null; + }); + await screen.getByRole("button", "Newer conversation", { exact: false }).tap(); + const newerMessage = screen.getByText("Stay in this conversation", { exact: true }); + await newerMessage.waitFor(); + const newerUrl = await browser.url(); + await browser.evaluate(async () => { + await window.reopenGate.release(); + return null; + }); + + await app.screenshot("conversation-after-browser-reopens"); + await expect(browser).toHaveURL(newerUrl); + }, +); From c6cfca0c5d60019d7a7195e66cd1abbec6476e92 Mon Sep 17 00:00:00 2001 From: Wout Stiens <71498452+StiensWout@users.noreply.github.com> Date: Sat, 21 Nov 2026 20:21:31 +0100 Subject: [PATCH 2/6] fix(web): preserve newer navigation when reopening closed views Co-authored-by: GPT 6.2 Sol --- .../ReopenClosedViewShortcut.browser.test.tsx | 40 ++++++++++++++++++- .../components/ReopenClosedViewShortcut.tsx | 30 ++++++++++---- 2 files changed, 61 insertions(+), 9 deletions(-) diff --git a/apps/web/src/components/ReopenClosedViewShortcut.browser.test.tsx b/apps/web/src/components/ReopenClosedViewShortcut.browser.test.tsx index 406e3d79bd57d..d55dd1271b366 100644 --- a/apps/web/src/components/ReopenClosedViewShortcut.browser.test.tsx +++ b/apps/web/src/components/ReopenClosedViewShortcut.browser.test.tsx @@ -122,9 +122,10 @@ async function renderShortcut() { stack.defer(() => { delete window.desktopBridge; }); - stack.use(await render()); + const screen = stack.use(await render()); const environment = stack.move(); return { + router: screen.router!, /** Attaches an element to the document until the test ends. */ append(element: HTMLElement) { document.body.append(element); @@ -148,6 +149,43 @@ function press(target: Element = document.body) { } describe("root reopen shortcut", () => { + it.each([ + { action: "switch routes", goBack: false, expectedPath: "/newer" }, + { action: "leave and return", goBack: true, expectedPath: "/" }, + ])( + "restores both queued views without navigating when you $action during the reopen", + async ({ goBack, expectedPath }) => { + setup(); + const store = useClosedViewStore.getState(); + store.remember({ kind: "panel-tab", threadRef: ref, surface: { kind: "diff", id: "diff" } }); + store.remember({ kind: "browser", threadRef: ref, snapshot }); + const result = Promise.withResolvers>(); + state.openPreview.mockReturnValue(result.promise); + await using view = await renderShortcut(); + const { history } = view.router; + state.navigate.mockImplementation(async () => { + history.push("/restored-owner"); + }); + + await act(() => { + press(); + menuAction?.("view.reopenClosed"); + }); + await act(() => { + history.push("/newer"); + if (goBack) history.back(); + }); + await act(() => result.resolve(AsyncResult.success({ tabId: "new-tab" }))); + + expect(useClosedViewStore.getState().entries).toEqual([]); + const panel = selectThreadRightPanelState(useRightPanelStore.getState().byThreadKey, ref); + expect(panel.surfaces.map((surface) => surface.id)).toEqual( + expect.arrayContaining(["browser:new-tab", "diff"]), + ); + expect(history.location.pathname).toBe(expectedPath); + }, + ); + it("serializes deliberate presses while a browser restore waits for RPC", async () => { setup(); useClosedViewStore diff --git a/apps/web/src/components/ReopenClosedViewShortcut.tsx b/apps/web/src/components/ReopenClosedViewShortcut.tsx index 551dbc98d8abc..90cdcebf8db72 100644 --- a/apps/web/src/components/ReopenClosedViewShortcut.tsx +++ b/apps/web/src/components/ReopenClosedViewShortcut.tsx @@ -7,7 +7,7 @@ import { scopeThreadRef, } from "@t3tools/client-runtime/environment"; import type { ScopedThreadRef } from "@t3tools/contracts"; -import { useNavigate, useParams } from "@tanstack/react-router"; +import { useNavigate, useParams, useRouter } from "@tanstack/react-router"; import { useGT } from "gt-react"; import { useEffect, useEffectEvent, useRef } from "react"; @@ -72,6 +72,7 @@ const isGlobalIssues = (ref: ScopedThreadRef) => export function ReopenClosedViewShortcut() { const gt = useGT(); const navigate = useNavigate(); + const router = useRouter(); const params = useParams({ strict: false }); const target = resolveThreadRouteTarget(params); const draft = useComposerDraftStore((state) => @@ -94,8 +95,10 @@ export function ReopenClosedViewShortcut() { const hasHistory = useClosedViewStore((state) => state.entries.length > 0); const openPreview = useAtomCommand(previewEnvironment.open); const pending = useRef(Promise.resolve()); + type ReopenNavigation = { location: typeof router.history.location }; + const reopenNavigation = useRef(null); - const reopenNext = useEffectEvent(async () => { + const reopenNext = useEffectEvent(async (request: ReopenNavigation) => { const catalog = appAtomRegistry.get(environmentCatalog.catalogValueAtom); const drafts = useComposerDraftStore.getState(); const panelsByThread = useRightPanelStore.getState().byThreadKey; @@ -142,28 +145,39 @@ export function ReopenClosedViewShortcut() { return; } useClosedViewStore.getState().remove(restore.id); + if (router.history.location !== request.location) return; + + let navigation: Promise; if (globalPullRequests) { const selected = selectSelectedRightPanelSurface( useRightPanelStore.getState().byThreadKey, ref, ); - await navigate({ + navigation = navigate({ to: "/pull-requests", search: (previous) => pullRequestsSearchForRestore(previous, selected), }); } else if (globalIssues) { - await navigate({ to: "/issues", search: readIssueListPreferences() }); + navigation = navigate({ to: "/issues", search: readIssueListPreferences() }); } else { const draftId = thread === null ? drafts.getDraftIdByRef(ref) : null; - if (draftId !== null) - await navigate({ to: "/draft/$draftId", params: buildDraftThreadRouteParams(draftId) }); - else await navigate({ to: "/$environmentId/$threadId", params: buildThreadRouteParams(ref) }); + navigation = + draftId !== null + ? navigate({ to: "/draft/$draftId", params: buildDraftThreadRouteParams(draftId) }) + : navigate({ to: "/$environmentId/$threadId", params: buildThreadRouteParams(ref) }); } + // History updates before the route loads. Queued reopens can follow this hop only. + request.location = router.history.location; + await navigation; }); const enqueueReopen = useEffectEvent(() => { + const location = router.history.location; + const previous = reopenNavigation.current; + const request = previous?.location === location ? previous : { location }; + reopenNavigation.current = request; pending.current = pending.current - .then(() => reopenNext()) + .then(() => reopenNext(request)) .catch((error: unknown) => { toastManager.add({ type: "error", From e6a63651966f58e692a4d32bea1cc416f7a1180a Mon Sep 17 00:00:00 2001 From: Wout Stiens <71498452+StiensWout@users.noreply.github.com> Date: Sat, 21 Nov 2026 20:36:07 +0100 Subject: [PATCH 3/6] fix(web): follow queued reopens through deferred history commits Co-authored-by: GPT 6.2 Sol --- .../ReopenClosedViewShortcut.browser.test.tsx | 55 +++++++++++++++++++ .../components/ReopenClosedViewShortcut.tsx | 46 ++++++++++++---- 2 files changed, 91 insertions(+), 10 deletions(-) diff --git a/apps/web/src/components/ReopenClosedViewShortcut.browser.test.tsx b/apps/web/src/components/ReopenClosedViewShortcut.browser.test.tsx index d55dd1271b366..2b3e9bfb96c14 100644 --- a/apps/web/src/components/ReopenClosedViewShortcut.browser.test.tsx +++ b/apps/web/src/components/ReopenClosedViewShortcut.browser.test.tsx @@ -1,5 +1,13 @@ import type { ResolvedKeybindingsConfig, ScopedThreadRef } from "@t3tools/contracts"; import { DEFAULT_RESOLVED_KEYBINDINGS } from "@t3tools/shared/keybindings"; +import { + createMemoryHistory, + createRootRoute, + createRoute, + createRouter, + Outlet, + RouterProvider, +} from "@tanstack/react-router"; import * as Cause from "effect/Cause"; import { AsyncResult } from "effect/reactivity"; import { describe, expect, it, vi } from "vite-plus/test"; @@ -212,6 +220,53 @@ describe("root reopen shortcut", () => { expect(useClosedViewStore.getState().entries).toEqual([]); }); + it("follows both queued restores from a page with an allowing navigation blocker", async () => { + setup(); + const olderRef = { ...ref, threadId: "thread-2" } as ScopedThreadRef; + const store = useClosedViewStore.getState(); + store.remember({ + kind: "panel-tab", + threadRef: olderRef, + surface: { kind: "diff", id: "diff" }, + }); + store.remember({ kind: "browser", threadRef: ref, snapshot }); + const opened = Promise.withResolvers>(); + state.openPreview.mockReturnValue(opened.promise); + + const history = createMemoryHistory({ initialEntries: ["/welcome"] }); + const root = createRootRoute({ + component: () => ( + <> + + + + ), + }); + const router = createRouter({ + history, + routeTree: root.addChildren([ + createRoute({ getParentRoute: () => root, path: "welcome" }), + createRoute({ getParentRoute: () => root, path: "$environmentId/$threadId" }), + ]), + }); + state.navigate.mockImplementation(router.navigate); + using _platform = vi.spyOn(navigator, "platform", "get").mockReturnValue("Linux x86_64"); + // The test supplies its own routes and history. + await using _view = await render(, { router: false }); + using _blocker = { + [Symbol.dispose]: history.block({ blockerFn: () => false, enableBeforeUnload: false }), + }; + + await act(() => { + press(); + press(); + }); + await act(() => opened.resolve(AsyncResult.success({ tabId: "new-tab" }))); + + expect(useClosedViewStore.getState().entries).toEqual([]); + expect(history.location.pathname).toBe("/remote/thread-2"); + }); + it("does not create a second browser when navigation fails after restoring it", async () => { setup(); const store = useClosedViewStore.getState(); diff --git a/apps/web/src/components/ReopenClosedViewShortcut.tsx b/apps/web/src/components/ReopenClosedViewShortcut.tsx index 90cdcebf8db72..1bc9d62a20c8e 100644 --- a/apps/web/src/components/ReopenClosedViewShortcut.tsx +++ b/apps/web/src/components/ReopenClosedViewShortcut.tsx @@ -7,7 +7,7 @@ import { scopeThreadRef, } from "@t3tools/client-runtime/environment"; import type { ScopedThreadRef } from "@t3tools/contracts"; -import { useNavigate, useParams, useRouter } from "@tanstack/react-router"; +import { linkOptions, useNavigate, useParams, useRouter } from "@tanstack/react-router"; import { useGT } from "gt-react"; import { useEffect, useEffectEvent, useRef } from "react"; @@ -49,6 +49,12 @@ import { import { toastManager } from "./ui/toast"; import { readIssueListPreferences } from "./issue/issueListPreferences"; +declare module "@tanstack/react-router" { + interface HistoryState { + reopenedViewId?: string; + } +} + const PREVIEW_FORWARDED_COMMANDS = [ "workspace.focusNext", "workspace.focusPrevious", @@ -147,28 +153,48 @@ export function ReopenClosedViewShortcut() { useClosedViewStore.getState().remove(restore.id); if (router.history.location !== request.location) return; - let navigation: Promise; + let destination; if (globalPullRequests) { const selected = selectSelectedRightPanelSurface( useRightPanelStore.getState().byThreadKey, ref, ); - navigation = navigate({ + destination = linkOptions({ to: "/pull-requests", search: (previous) => pullRequestsSearchForRestore(previous, selected), }); } else if (globalIssues) { - navigation = navigate({ to: "/issues", search: readIssueListPreferences() }); + destination = linkOptions({ to: "/issues", search: readIssueListPreferences() }); } else { const draftId = thread === null ? drafts.getDraftIdByRef(ref) : null; - navigation = + destination = draftId !== null - ? navigate({ to: "/draft/$draftId", params: buildDraftThreadRouteParams(draftId) }) - : navigate({ to: "/$environmentId/$threadId", params: buildThreadRouteParams(ref) }); + ? linkOptions({ to: "/draft/$draftId", params: buildDraftThreadRouteParams(draftId) }) + : linkOptions({ to: "/$environmentId/$threadId", params: buildThreadRouteParams(ref) }); + } + + const { history } = router; + if (router.buildLocation(destination).publicHref === history.location.href) { + const { reopenedViewId } = history.location.state; + await navigate({ ...destination, state: reopenedViewId ? { reopenedViewId } : {} }); + return; + } + + // An allowing blocker can defer the commit. Only the reopen's first history hop extends the queue. + const unsubscribe = history.subscribe(({ location, action }) => { + if (location === request.location) return; + unsubscribe(); + if (action.type === "PUSH" && location.state.reopenedViewId === restore.id) { + request.location = location; + } + }); + try { + await navigate({ ...destination, state: { reopenedViewId: restore.id } }); + } catch (error) { + unsubscribe(); + throw error; } - // History updates before the route loads. Queued reopens can follow this hop only. - request.location = router.history.location; - await navigation; + unsubscribe(); }); const enqueueReopen = useEffectEvent(() => { From b1cfb334ad695319e4341b0ccf48d2420bf1ac30 Mon Sep 17 00:00:00 2001 From: Wout Stiens <71498452+StiensWout@users.noreply.github.com> Date: Sat, 21 Nov 2026 20:36:24 +0100 Subject: [PATCH 4/6] test(web): observe reopen history through the closed-view store Co-authored-by: GPT 6.2 Sol --- ...ning-browser-keeps-the-newer-thread.e2e.ts | 47 ++++++++++++++----- 1 file changed, 34 insertions(+), 13 deletions(-) diff --git a/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts b/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts index d1270ef325df4..5b3313043b037 100644 --- a/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts +++ b/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts @@ -1,4 +1,5 @@ /// +import { WS_METHODS } from "@t3tools/contracts"; import { expect } from "e2e"; import { test, WEB } from "./t3.ts"; @@ -6,10 +7,15 @@ import { test, WEB } from "./t3.ts"; interface ReopenGate { readonly closed: Promise; readonly requested: Promise; + readonly observeHistory: (modulePath: string) => Promise; readonly arm: () => void; readonly release: () => Promise; } +interface ClosedViewHistory { + readonly entries: readonly { readonly id: string }[]; +} + declare global { interface Window { reopenGate: ReopenGate; @@ -28,29 +34,19 @@ test( messages: ["Stay in this conversation"], }); - await browser.addInitScript(() => { + await browser.addInitScript((previewOpenMethod) => { const closed = Promise.withResolvers(); const requested = Promise.withResolvers(); const restored = Promise.withResolvers(); - let hasClosedBrowser = false; let armed = false; let sendHeld = () => {}; - const setItem = Storage.prototype.setItem; - Storage.prototype.setItem = function (key, value) { - setItem.call(this, key, value); - if (key !== "t3code:closed-views:v2") return; - const hasBrowser = value.includes('"kind":"browser"'); - if (hasBrowser) closed.resolve(); - else if (hasClosedBrowser) restored.resolve(); - hasClosedBrowser = hasBrowser; - }; const send = WebSocket.prototype.send; WebSocket.prototype.send = function (data) { if (!armed || typeof data !== "string") return send.call(this, data); const parsed = JSON.parse(data); const messages = [parsed].flat(); const isOpen = (message: { _tag?: string; tag?: string }) => - message._tag === "Request" && message.tag === "preview.open"; + message._tag === "Request" && message.tag === previewOpenMethod; const previewOpens = messages.filter(isOpen); if (previewOpens.length === 0) return send.call(this, data); armed = false; @@ -63,6 +59,27 @@ test( window.reopenGate = { closed: closed.promise, requested: requested.promise, + observeHistory: async (modulePath) => { + const { useClosedViewStore } = (await import(modulePath)) as { + useClosedViewStore: { + subscribe: ( + listener: (state: ClosedViewHistory, previous: ClosedViewHistory) => void, + ) => () => void; + }; + }; + let closedId: string | undefined; + const unsubscribe = useClosedViewStore.subscribe(({ entries }, previous) => { + if (closedId === undefined) { + closedId = entries.find( + (entry) => !previous.entries.some((old) => old.id === entry.id), + )?.id; + if (closedId !== undefined) closed.resolve(); + } else if (!entries.some((entry) => entry.id === closedId)) { + unsubscribe(); + restored.resolve(); + } + }); + }, arm: () => { armed = true; }, @@ -71,11 +88,15 @@ test( return restored.promise; }, }; - }); + }, WS_METHODS.previewOpen); await t3.open(owner); await screen.getByRole("button", "Toggle right panel").tap(); await screen.getByRole("button", "Browser B").tap(); + await browser.evaluate(async (modulePath) => { + await window.reopenGate.observeHistory(modulePath); + return null; + }, "/src/closedViewStore.ts"); await screen.getByRole("button", "Close Browser", { exact: true }).tap(); await browser.evaluate(async () => { await window.reopenGate.closed; From 12713af87d33e62dbb6205d1a774a7fa298cfd8b Mon Sep 17 00:00:00 2001 From: Wout Stiens <71498452+StiensWout@users.noreply.github.com> Date: Sat, 21 Nov 2026 20:39:04 +0100 Subject: [PATCH 5/6] test(web): restore the original browser reopen scenario probe Co-authored-by: GPT 6.2 Sol --- ...ning-browser-keeps-the-newer-thread.e2e.ts | 47 +++++-------------- 1 file changed, 13 insertions(+), 34 deletions(-) diff --git a/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts b/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts index 5b3313043b037..d1270ef325df4 100644 --- a/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts +++ b/scripts/scenarios/reopening-browser-keeps-the-newer-thread.e2e.ts @@ -1,5 +1,4 @@ /// -import { WS_METHODS } from "@t3tools/contracts"; import { expect } from "e2e"; import { test, WEB } from "./t3.ts"; @@ -7,15 +6,10 @@ import { test, WEB } from "./t3.ts"; interface ReopenGate { readonly closed: Promise; readonly requested: Promise; - readonly observeHistory: (modulePath: string) => Promise; readonly arm: () => void; readonly release: () => Promise; } -interface ClosedViewHistory { - readonly entries: readonly { readonly id: string }[]; -} - declare global { interface Window { reopenGate: ReopenGate; @@ -34,19 +28,29 @@ test( messages: ["Stay in this conversation"], }); - await browser.addInitScript((previewOpenMethod) => { + await browser.addInitScript(() => { const closed = Promise.withResolvers(); const requested = Promise.withResolvers(); const restored = Promise.withResolvers(); + let hasClosedBrowser = false; let armed = false; let sendHeld = () => {}; + const setItem = Storage.prototype.setItem; + Storage.prototype.setItem = function (key, value) { + setItem.call(this, key, value); + if (key !== "t3code:closed-views:v2") return; + const hasBrowser = value.includes('"kind":"browser"'); + if (hasBrowser) closed.resolve(); + else if (hasClosedBrowser) restored.resolve(); + hasClosedBrowser = hasBrowser; + }; const send = WebSocket.prototype.send; WebSocket.prototype.send = function (data) { if (!armed || typeof data !== "string") return send.call(this, data); const parsed = JSON.parse(data); const messages = [parsed].flat(); const isOpen = (message: { _tag?: string; tag?: string }) => - message._tag === "Request" && message.tag === previewOpenMethod; + message._tag === "Request" && message.tag === "preview.open"; const previewOpens = messages.filter(isOpen); if (previewOpens.length === 0) return send.call(this, data); armed = false; @@ -59,27 +63,6 @@ test( window.reopenGate = { closed: closed.promise, requested: requested.promise, - observeHistory: async (modulePath) => { - const { useClosedViewStore } = (await import(modulePath)) as { - useClosedViewStore: { - subscribe: ( - listener: (state: ClosedViewHistory, previous: ClosedViewHistory) => void, - ) => () => void; - }; - }; - let closedId: string | undefined; - const unsubscribe = useClosedViewStore.subscribe(({ entries }, previous) => { - if (closedId === undefined) { - closedId = entries.find( - (entry) => !previous.entries.some((old) => old.id === entry.id), - )?.id; - if (closedId !== undefined) closed.resolve(); - } else if (!entries.some((entry) => entry.id === closedId)) { - unsubscribe(); - restored.resolve(); - } - }); - }, arm: () => { armed = true; }, @@ -88,15 +71,11 @@ test( return restored.promise; }, }; - }, WS_METHODS.previewOpen); + }); await t3.open(owner); await screen.getByRole("button", "Toggle right panel").tap(); await screen.getByRole("button", "Browser B").tap(); - await browser.evaluate(async (modulePath) => { - await window.reopenGate.observeHistory(modulePath); - return null; - }, "/src/closedViewStore.ts"); await screen.getByRole("button", "Close Browser", { exact: true }).tap(); await browser.evaluate(async () => { await window.reopenGate.closed; From b2721d71416ef0ff52788dfc9924e8fbe29ed298 Mon Sep 17 00:00:00 2001 From: Wout Stiens <71498452+StiensWout@users.noreply.github.com> Date: Sat, 21 Nov 2026 20:42:05 +0100 Subject: [PATCH 6/6] chore: credit the models that worked on this change Co-authored-by: Claude Opus 5.5