@devries-cameron20 / t3code Mirror · read-only / commits / ed101ef641
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 13:30 UTC

fix(preview): unload desktop pages before removing their tabs (#35135)

Co-authored-by: Julius Marminge <julius0216@outlook.com>

kirat02 committed Nov 15, 2026 at 03:30 UTC ed101ef641fe75e1a86c7ff7ef34a09955765307
6 files changed +299 -42
apps/server/src/preview/Manager.ts
+26 -6
@@ -60,6 +60,10 @@ export class PreviewManager extends Context.Service<
60 input: PreviewAdjustInput,
61 ) => Effect.Effect<PreviewSessionSnapshot, PreviewError>;
62 readonly close: (input: PreviewCloseInput) => Effect.Effect<void, PreviewError>;
63 + /** Runs before closed events publish, while clients still own their page surfaces. */
64 + readonly registerBeforeClose: (
65 + handler: (snapshots: ReadonlyArray<PreviewSessionSnapshot>) => Effect.Effect<void>,
66 + ) => Effect.Effect<void, never, Scope.Scope>;
67 readonly list: (input: PreviewListInput) => Effect.Effect<PreviewListResult>;
68 readonly events: Stream.Stream<PreviewEvent>;
69 readonly subscribeEvents: Effect.Effect<PubSub.Subscription<PreviewEvent>, never, Scope.Scope>;
@@ -128,6 +132,14 @@ export const make = Effect.gen(function* PreviewManagerMake() {
132 const stateRef = yield* SynchronizedRef.make<ManagerState>(initialState);
133 const eventsPubSub = yield* PubSub.unbounded<PreviewEvent>();
134 const events: Stream.Stream<PreviewEvent> = Stream.fromPubSub(eventsPubSub);
135 + const beforeClose = new Set<
136 + (snapshots: ReadonlyArray<PreviewSessionSnapshot>) => Effect.Effect<void>
137 + >();
138 + const registerBeforeClose: PreviewManager["Service"]["registerBeforeClose"] = (handler) =>
139 + Effect.acquireRelease(
140 + Effect.sync(() => beforeClose.add(handler)),
141 + () => Effect.sync(() => beforeClose.delete(handler)),
142 + ).pipe(Effect.asVoid);
143
144 /** Publish inside the lock to preserve state-transition order. */
145 const mutateExistingSession = <R, E>(
@@ -395,19 +407,26 @@ export const make = Effect.gen(function* PreviewManagerMake() {
407
408 const close: PreviewManager["Service"]["close"] = Effect.fn("PreviewManager.close")(
409 function* (input) {
410 + // Unload runs outside the state lock; tabs opened meanwhile belong to a later close.
411 + const current = yield* SynchronizedRef.get(stateRef);
412 + const targets = input.tabId
413 + ? [current.sessions.get(compositeKey(input.threadId, input.tabId))].filter(
414 + (entry): entry is PreviewSessionState => entry !== undefined,
415 + )
416 + : sessionsForThread(current, input.threadId);
417 + yield* Effect.forEach(
418 + [...beforeClose],
419 + (handler) => handler(targets.map((target) => target.snapshot)),
420 + { discard: true },
421 + );
422 const createdAt = yield* currentIsoTimestamp;
423 yield* SynchronizedRef.modifyEffect(stateRef, (state) => {
424 const eventsToEmit: PreviewEvent[] = [];
425 const sessions = new Map(state.sessions);
402 - const targets = input.tabId
403 - ? [state.sessions.get(compositeKey(input.threadId, input.tabId))].filter(
404 - (entry): entry is PreviewSessionState => entry !== undefined,
405 - )
406 - : sessionsForThread(state, input.threadId);
426 let revision = state.revision;
427 for (const target of targets) {
428 + if (!sessions.delete(compositeKey(target.threadId, target.tabId))) continue;
429 revision += 1;
410 - sessions.delete(compositeKey(target.threadId, target.tabId));
430 eventsToEmit.push({
431 type: "closed",
432 threadId: target.threadId,
@@ -484,6 +503,7 @@ export const make = Effect.gen(function* PreviewManagerMake() {
503 resize,
504 adjust,
505 close,
506 + registerBeforeClose,
507 list,
508 events,
509 subscribeEvents: PubSub.subscribe(eventsPubSub),
apps/server/src/preview/ServerBrowser.test.ts
+147 -22
@@ -74,6 +74,8 @@ vi.mock("./ServerBrowserContexts.ts", () => ({
74 context.page.viewportSize.mockReturnValue(null);
75 const browser = { close: vi.fn(async () => {}) };
76 desktopConnections.push({ endpoint, context, browser });
77 + desktopConnectionStarted?.resolve();
78 + await desktopConnectionGate?.promise;
79 return { browser, page: context.page as unknown as Page };
80 }
81 async close() {
@@ -401,6 +403,8 @@ let pageSetupFailure: Error | null = null;
403 let initialNavigation: (() => Promise<void>) | null = null;
404 let desktopRendersNext = false;
405 let desktopPageUrl = "about:blank";
406 +let desktopConnectionGate: PromiseWithResolvers<void> | null = null;
407 +let desktopConnectionStarted: PromiseWithResolvers<void> | null = null;
408 /** Replaces the answer to the desktop page's size reads. */
409 let desktopSizeAnswer: (() => Promise<Record<string, unknown>>) | null = null;
410 const desktopDetaches = new NodeEvents.EventEmitter();
@@ -593,6 +597,8 @@ beforeEach(() => {
597 desktopAttachesLate = false;
598 desktopAttachWaiting = Promise.withResolvers<void>();
599 desktopPageUrl = "about:blank";
600 + desktopConnectionGate = null;
601 + desktopConnectionStarted = null;
602 desktopSizeAnswer = null;
603 desktopDetachReady = Promise.withResolvers<void>();
604 desktopReleased = Promise.withResolvers<void>();
@@ -1833,46 +1839,111 @@ it.effect("closing a tab force-closes a page that never finishes unloading", ()
1839 ).pipe(Effect.provide(layer)),
1840 );
1841
1836 -it.effect("closing a desktop tab waits for its page to unload before the desktop removes it", () =>
1842 +it.effect("closing a desktop tab during setup unloads its page before disconnecting", () =>
1843 Effect.scoped(
1844 Effect.gen(function* () {
1845 const { broker } = yield* ready;
1846 const manager = yield* Manager.PreviewManager;
1847 desktopRendersNext = true;
1842 - const opened = yield* broker.invoke<PreviewAutomationStatus>({
1843 - scope,
1844 - operation: "open",
1845 - input: { reuseExistingTab: false, open: false },
1846 - });
1847 - const tabId = PreviewTabId.make(opened.tabId!);
1848 + const gate = (desktopConnectionGate = Promise.withResolvers<void>());
1849 + const started = (desktopConnectionStarted = Promise.withResolvers<void>());
1850 + yield* Effect.addFinalizer(() => Effect.sync(() => gate.resolve()));
1851 + const opening = yield* broker
1852 + .invoke<PreviewAutomationStatus>({
1853 + scope,
1854 + operation: "open",
1855 + input: { reuseExistingTab: false, open: false },
1856 + })
1857 + .pipe(Effect.result, Effect.forkScoped);
1858 + yield* Effect.promise(() => started.promise);
1859 const { context, browser } = desktopConnections[0]!;
1860 const page = context.page;
1850 - // The desktop removes the webview once the session closes, dropping an unload in progress.
1851 - const events = yield* manager.subscribeEvents;
1852 - const sessionClosed = Promise.withResolvers<void>();
1853 - yield* Effect.gen(function* () {
1854 - while ((yield* PubSub.take(events)).type !== "closed");
1855 - page.removed = true;
1856 - sessionClosed.resolve();
1857 - }).pipe(Effect.forkScoped);
1861 page.beforeUnload = "listen";
1862 page.unloadGate = Promise.withResolvers<void>();
1860 - const closing = yield* broker
1861 - .invoke({ scope, tabId, operation: "close", input: {} })
1862 - .pipe(Effect.forkScoped);
1863 - // The page finishes unloading once the server listens for it, or too late if it never does.
1863 + const { sessions } = yield* manager.list({ threadId: testThread.threadId });
1864 + const session = sessions.find((candidate) => !candidate.headless)!;
1865 + const closing = yield* manager
1866 + .close({ threadId: testThread.threadId, tabId: session.tabId })
1867 + .pipe(Effect.forkScoped({ startImmediately: true }));
1868 + expect(page.isClosed()).toBe(false);
1869 + gate.resolve();
1870 yield* Effect.promise(() =>
1865 - Promise.race([page.pagehideWatched.promise, sessionClosed.promise]),
1871 + Promise.race([page.pagehideWatched.promise, desktopReleased.promise]),
1872 + );
1873 + expect((yield* manager.list({ threadId: testThread.threadId })).sessions).toEqual(
1874 + expect.arrayContaining([expect.objectContaining({ tabId: session.tabId })]),
1875 );
1867 - expect(browser.close).not.toHaveBeenCalled();
1876 page.unloadGate.resolve();
1877 yield* Fiber.join(closing);
1878 + expect(yield* Fiber.join(opening)).toMatchObject({ _tag: "Failure" });
1879 + yield* Effect.promise(() => desktopReleased.promise);
1880 expect(page.unloadEvents).toEqual(["beforeunload", "pagehide", "visibilitychange"]);
1871 - expect(browser.close).toHaveBeenCalledTimes(1);
1881 + expect(page.isClosed()).toBe(true);
1882 + expect(browser.close).toHaveBeenCalled();
1883 }),
1884 ).pipe(Effect.provide(layer)),
1885 );
1886
1887 +it.effect.each(["agent", "client", "all", "concurrent"] as const)(
1888 + "closing a desktop tab waits for unload before removal (%s)",
1889 + (source) =>
1890 + Effect.scoped(
1891 + Effect.gen(function* () {
1892 + const { broker } = yield* ready;
1893 + const manager = yield* Manager.PreviewManager;
1894 + desktopRendersNext = true;
1895 + const opened = yield* broker.invoke<PreviewAutomationStatus>({
1896 + scope,
1897 + operation: "open",
1898 + input: { reuseExistingTab: false, open: false },
1899 + });
1900 + const tabId = PreviewTabId.make(opened.tabId!);
1901 + const { context, browser } = desktopConnections[0]!;
1902 + const page = context.page;
1903 + // The desktop removes the webview once the session closes, dropping an unload in progress.
1904 + const events = yield* manager.subscribeEvents;
1905 + const sessionClosed = Promise.withResolvers<void>();
1906 + yield* Effect.gen(function* () {
1907 + while ((yield* PubSub.take(events)).type !== "closed");
1908 + page.removed = true;
1909 + sessionClosed.resolve();
1910 + }).pipe(Effect.forkScoped);
1911 + page.beforeUnload = "listen";
1912 + page.unloadGate = Promise.withResolvers<void>();
1913 + const close = () => manager.close({ threadId: testThread.threadId, tabId });
1914 + const closing = yield* (
1915 + source === "agent"
1916 + ? broker.invoke({ scope, tabId, operation: "close", input: {} })
1917 + : source === "all"
1918 + ? manager.close({ threadId: testThread.threadId })
1919 + : source === "concurrent"
1920 + ? Effect.all([close(), close()], { concurrency: "unbounded", discard: true })
1921 + : close()
1922 + ).pipe(Effect.forkScoped);
1923 + // The page finishes unloading once the server listens for it, or too late if it never does.
1924 + yield* Effect.promise(() =>
1925 + Promise.race([page.pagehideWatched.promise, sessionClosed.promise]),
1926 + );
1927 + expect(browser.close).not.toHaveBeenCalled();
1928 + const openedDuringClose =
1929 + source === "all"
1930 + ? yield* manager.open({ threadId: testThread.threadId, runtime: "server" })
1931 + : undefined;
1932 + page.unloadGate.resolve();
1933 + yield* Fiber.join(closing);
1934 + yield* Effect.promise(() => desktopReleased.promise);
1935 + expect(page.unloadEvents).toEqual(["beforeunload", "pagehide", "visibilitychange"]);
1936 + expect(browser.close).toHaveBeenCalledTimes(1);
1937 + if (openedDuringClose) {
1938 + const remaining = yield* manager.list({ threadId: testThread.threadId });
1939 + expect(remaining.sessions.map((session) => session.tabId)).toContain(
1940 + openedDuringClose.tabId,
1941 + );
1942 + }
1943 + }),
1944 + ).pipe(Effect.provide(layer)),
1945 +);
1946 +
1947 it.effect("closing a tab with an unsaved-changes guard still closes it", () =>
1948 Effect.scoped(
1949 Effect.gen(function* () {
@@ -3768,6 +3839,7 @@ it.effect("a full server takes back the slot of the longest idle agent tab nobod
3839 expect(releasedDesktopTabs).toEqual([]);
3840 shownDesktopTabs.clear();
3841 shownDesktopTabs.add(opened[1]!);
3842 + desktopConnections[2]!.context.page.beforeUnload = "listen";
3843 const events = yield* manager.subscribeEvents;
3844 const releases = yield* Queue.unbounded<string>();
3845 const recordRelease = (tabId: string) => Queue.offerUnsafe(releases, tabId);
@@ -3778,6 +3850,11 @@ it.effect("a full server takes back the slot of the longest idle agent tab nobod
3850 const fresh = yield* open("agent-new");
3851 expect(fresh.tabId).toBeDefined();
3852 expect(yield* Queue.take(releases)).toBe(opened[2]);
3853 + expect(desktopConnections[2]!.context.page.unloadEvents).toEqual([
3854 + "beforeunload",
3855 + "pagehide",
3856 + "visibilitychange",
3857 + ]);
3858 yield* Stream.fromSubscription(events).pipe(
3859 Stream.filter((event) => event.type === "closed" && event.tabId === opened[2]),
3860 Stream.runHead,
@@ -3787,6 +3864,54 @@ it.effect("a full server takes back the slot of the longest idle agent tab nobod
3864 expect(sessions.map((session) => session.tabId).toSorted()).toEqual(
3865 [...opened.filter((tabId) => tabId !== opened[2]), fresh.tabId!].toSorted(),
3866 );
3867 +
3868 + // A second open must reclaim a different tab while the first page is unloading.
3869 + const closingPage = desktopConnections[3]!.context.page;
3870 + closingPage.beforeUnload = "listen";
3871 + closingPage.unloadGate = Promise.withResolvers<void>();
3872 + const closeRequests = yield* Queue.unbounded<void>();
3873 + const close = manager.close;
3874 + const closeSpy = vi
3875 + .spyOn(manager, "close")
3876 + .mockImplementation((input) =>
3877 + Queue.offer(closeRequests, undefined).pipe(Effect.andThen(close(input))),
3878 + );
3879 + yield* Effect.addFinalizer(() => Effect.sync(() => closeSpy.mockRestore()));
3880 + const firstOpen = yield* open("agent-concurrent").pipe(Effect.forkScoped);
3881 + yield* Queue.take(closeRequests);
3882 + yield* Effect.promise(() => closingPage.pagehideWatched.promise);
3883 + const secondOpen = yield* open("agent-concurrent").pipe(Effect.forkScoped);
3884 + yield* Queue.take(closeRequests);
3885 + closingPage.unloadGate.resolve();
3886 + const concurrent = yield* Effect.all([Fiber.join(firstOpen), Fiber.join(secondOpen)]);
3887 + expect(concurrent.every((status) => status.available)).toBe(true);
3888 + const remaining = (yield* manager.list({ threadId: scope.thread.threadId })).sessions;
3889 + expect(remaining).toHaveLength(32);
3890 + const closedBeforeReturn = yield* Deferred.make<void>();
3891 + const finishClose = yield* Deferred.make<void>();
3892 + let heldClose = false;
3893 + closeSpy.mockImplementation((input) => {
3894 + const hold = !heldClose;
3895 + heldClose = true;
3896 + return close(input).pipe(
3897 + Effect.andThen(
3898 + hold
3899 + ? Deferred.succeed(closedBeforeReturn, undefined).pipe(
3900 + Effect.andThen(Deferred.await(finishClose)),
3901 + )
3902 + : Effect.void,
3903 + ),
3904 + );
3905 + });
3906 + const reclaimingOpen = yield* open("agent-reclaiming").pipe(Effect.forkScoped);
3907 + yield* Deferred.await(closedBeforeReturn);
3908 + const takingFreedSlot = yield* open("agent-taking-free-slot");
3909 + expect(takingFreedSlot.available).toBe(true);
3910 + yield* Deferred.succeed(finishClose, undefined);
3911 + expect((yield* Fiber.join(reclaimingOpen)).available).toBe(true);
3912 + expect((yield* manager.list({ threadId: scope.thread.threadId })).sessions).toHaveLength(32);
3913 + expect(remaining.some((session) => session.tabId === opened[3])).toBe(false);
3914 + expect(remaining.some((session) => session.tabId === opened[4])).toBe(false);
3915 }),
3916 ).pipe(Effect.provide(layer)),
3917 );
apps/server/src/preview/ServerBrowser.ts
+62 -11
@@ -969,6 +969,36 @@ const make = Effect.gen(function* () {
969 clearTimeout(timeout);
970 };
971
972 + const unloadingTabs = new WeakMap<ServerTab, Promise<void>>();
973 + yield* manager.registerBeforeClose((snapshots) =>
974 + Effect.promise(async () => {
975 + await Promise.all(
976 + snapshots.map((snapshot) => {
977 + const key = tabKey(snapshot.threadId, snapshot.tabId);
978 + const tab = tabs.get(key);
979 + if (!tab) {
980 + const opening = pendingTabs.get(key);
981 + if (!opening) return;
982 + closedPendingTabs.add(key);
983 + if (!opening.promise) return;
984 + const settled = Promise.withResolvers<void>();
985 + const timeout = setTimeout(settled.resolve, PAGE_CLOSE_GRACE_MS);
986 + void opening.promise.finally(settled.resolve).catch(constVoid);
987 + return settled.promise.finally(() => clearTimeout(timeout));
988 + }
989 + void tab.control.close().catch(constVoid);
990 + if (!tab.desktop || tab.dialog !== null) return;
991 + const pending = unloadingTabs.get(tab);
992 + if (pending) return pending;
993 + tab.closing = true;
994 + const unloading = unloadDesktopPage(tab.page);
995 + unloadingTabs.set(tab, unloading);
996 + return unloading;
997 + }),
998 + );
999 + }),
1000 + );
1001 +
1002 const dropTab = (tab: ServerTab, closeSession: boolean, reopening = false) => {
1003 const key = tabKey(tab.threadId, tab.tabId);
1004 if (tabs.get(key) !== tab) return;
@@ -1317,6 +1347,10 @@ const make = Effect.gen(function* () {
1347 page.on("popup", (popup) => void adoptPopup(tab, popup));
1348 const key = tabKey(tab.threadId, tab.tabId);
1349 if (closedPendingTabs.delete(key)) {
1350 + if (desktop) {
1351 + tab.closing = true;
1352 + await unloadDesktopPage(page).catch(constVoid);
1353 + }
1354 await control.close().catch(constVoid);
1355 throw new ServerBrowserTabNotFoundError({ threadId: tab.threadId, tabId: tab.tabId });
1356 }
@@ -1747,20 +1781,35 @@ const make = Effect.gen(function* () {
1781 const isVisible = (tab: ServerTab) =>
1782 tab.viewers.size > 0 || (tab.desktop !== null && desktopChannel.isShown(tab));
1783
1784 + const reclaimingTabs = new Set<ServerTab>();
1785 const idleAgentTabs = () => {
1786 const cutoff = Date.now() - AGENT_TAB_IDLE_MS;
1787 return [...tabs.values()].filter(
1753 - (tab) => tab.control.agentId !== null && !isVisible(tab) && tab.usedAt < cutoff,
1788 + (tab) =>
1789 + tab.control.agentId !== null &&
1790 + !reclaimingTabs.has(tab) &&
1791 + !isVisible(tab) &&
1792 + tab.usedAt < cutoff,
1793 );
1794 };
1795
1796 // The desktop app renders every server tab, so idle desktop agent tabs would otherwise
1797 // hold the server's budget forever. Hidden ones give up their slots, longest idle first,
1798 // only when an agent needs one and has room for it.
1760 - const freeIdleAgentSlot = (agentSessionId: string) => {
1799 + const freeIdleAgentSlot = async (agentSessionId: string) => {
1800 if (!serverAtTabLimit() || agentAtTabLimit(agentSessionId)) return;
1801 const longestIdle = idleAgentTabs().sort((left, right) => left.usedAt - right.usedAt)[0];
1763 - if (longestIdle) dropTab(longestIdle, true);
1802 + if (longestIdle) {
1803 + reclaimingTabs.add(longestIdle);
1804 + try {
1805 + await runPromise(
1806 + manager.close({ threadId: longestIdle.threadId, tabId: longestIdle.tabId }),
1807 + );
1808 + dropTab(longestIdle, false);
1809 + } finally {
1810 + reclaimingTabs.delete(longestIdle);
1811 + }
1812 + }
1813 };
1814
1815 // A Playwright launch must settle before its capacity can be released.
@@ -1771,10 +1820,17 @@ const make = Effect.gen(function* () {
1820 let key: string = NodeCrypto.randomUUID();
1821 const reservation = { agentId: input.automationOwner ?? null };
1822 return yield* Effect.acquireUseRelease(
1774 - Effect.try({
1775 - try: () => {
1823 + Effect.tryPromise({
1824 + try: async () => {
1825 if (input.automationOwner !== undefined) {
1777 - if (options.reclaimIdleSlot) freeIdleAgentSlot(input.automationOwner);
1826 + while (
1827 + options.reclaimIdleSlot &&
1828 + serverAtTabLimit() &&
1829 + !agentAtTabLimit(input.automationOwner) &&
1830 + idleAgentTabs().length > 0
1831 + ) {
1832 + await freeIdleAgentSlot(input.automationOwner);
1833 + }
1834 assertTabCapacity(input.automationOwner);
1835 }
1836 pendingTabs.set(key, reservation);
@@ -2654,11 +2710,6 @@ const make = Effect.gen(function* () {
2710 message: "A human controls this tab.",
2711 reason: "humanControl",
2712 });
2657 - void tab.control.close().catch(constVoid);
2658 - if (tab.desktop && tab.dialog === null) {
2659 - tab.closing = true;
2660 - await unloadDesktopPage(tab.page);
2661 - }
2713 await runPromise(manager.close({ threadId: tab.threadId, tabId: tab.tabId }));
2714 dropTab(tab, false);
2715 return {};
apps/web/src/components/preview/closePreviewSession.test.ts
+44 -1
@@ -1,9 +1,10 @@
1 import type {
2 + EnvironmentId,
3 PreviewCloseInput,
4 PreviewSessionSnapshot,
5 ScopedThreadRef,
6 } from "@t3tools/contracts";
6 -import { AsyncResult } from "effect/reactivity";
7 +import { Atom, AsyncResult } from "effect/reactivity";
8 import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
9
10 import {
@@ -13,9 +14,20 @@ import {
14 } from "~/previewStateStore";
15
16 import { useClosedViewStore } from "~/closedViewStore";
17 +import { appAtomRegistry } from "~/rpc/atomRegistry";
18 +import { primaryEnvironmentIdAtom } from "~/state/primaryEnvironment";
19
20 import { closePreviewSession } from "./closePreviewSession";
21
22 +vi.mock("~/env", async (importOriginal) => ({
23 + ...(await importOriginal<typeof import("~/env")>()),
24 + isElectron: true,
25 +}));
26 +vi.mock("~/state/primaryEnvironment", async (importOriginal) => ({
27 + ...(await importOriginal<typeof import("~/state/primaryEnvironment")>()),
28 + primaryEnvironmentIdAtom: Atom.make<EnvironmentId | null>(null),
29 +}));
30 +
31 const threadRef = {
32 environmentId: "local" as ScopedThreadRef["environmentId"],
33 threadId: "thread-1" as ScopedThreadRef["threadId"],
@@ -34,8 +46,16 @@ const snapshot: PreviewSessionSnapshot = {
46 updatedAt: "2026-06-18T19:00:00.000Z",
47 };
48
49 +const setPrimaryEnvironment = (environmentId: EnvironmentId | null) => {
50 + if (!Atom.isWritable<EnvironmentId | null, EnvironmentId | null>(primaryEnvironmentIdAtom)) {
51 + throw new Error("primaryEnvironmentIdAtom is not writable");
52 + }
53 + appAtomRegistry.set(primaryEnvironmentIdAtom, environmentId);
54 +};
55 +
56 beforeEach(() => {
57 resetPreviewStateForTests();
58 + setPrimaryEnvironment(null);
59 useClosedViewStore.setState({ entries: [] });
60 });
61
@@ -69,4 +89,27 @@ describe("closePreviewSession", () => {
89 ]);
90 expect(closePreview).toHaveBeenCalledWith({ threadId: "thread-1", tabId: "tab-1" });
91 });
92 +
93 + it("keeps a tab this desktop renders mounted until the server has closed it", async () => {
94 + setPrimaryEnvironment(threadRef.environmentId);
95 + const desktopSnapshot = { ...snapshot, runtime: "server" as const };
96 + applyPreviewServerSnapshot(threadRef, desktopSnapshot);
97 + let finishClose: (() => void) | undefined;
98 + const closing = closePreviewSession({
99 + closePreview: () =>
100 + new Promise<ReturnType<typeof AsyncResult.success<void>>>((resolve) => {
101 + finishClose = () => resolve(AsyncResult.success(undefined));
102 + }),
103 + snapshot: desktopSnapshot,
104 + tabId: desktopSnapshot.tabId,
105 + threadRef,
106 + });
107 +
108 + expect(readThreadPreviewState(threadRef).sessions).toEqual({ "tab-1": desktopSnapshot });
109 + finishClose?.();
110 + await closing;
111 + expect(readThreadPreviewState(threadRef).sessions).toEqual({});
112 + applyPreviewServerSnapshot(threadRef, desktopSnapshot);
113 + expect(readThreadPreviewState(threadRef).sessions).toEqual({});
114 + });
115 });
apps/web/src/components/preview/closePreviewSession.ts
+15 -2
@@ -6,8 +6,11 @@ import type {
6 ScopedThreadRef,
7 } from "@t3tools/contracts";
8
9 +import { rendersServerTabNatively } from "~/browser/previewRuntime";
10 import { useClosedViewStore } from "~/closedViewStore";
11 import { beginPreviewSessionClose, cancelPreviewSessionClose } from "~/previewStateStore";
12 +import { appAtomRegistry } from "~/rpc/atomRegistry";
13 +import { primaryEnvironmentIdAtom } from "~/state/primaryEnvironment";
14
15 interface ClosePreviewSessionInput<E> {
16 readonly closePreview: (input: {
@@ -22,14 +25,24 @@ interface ClosePreviewSessionInput<E> {
25 export async function closePreviewSession<E>(
26 input: ClosePreviewSessionInput<E>,
27 ): Promise<AtomCommandResult<void, E>> {
25 - beginPreviewSessionClose(input.threadRef, input.tabId);
28 + // Unmounting a webview destroys its page, so a tab this window renders stays mounted until the
29 + // server has unloaded it.
30 + const keepMounted = rendersServerTabNatively(
31 + input.threadRef.environmentId,
32 + appAtomRegistry.get(primaryEnvironmentIdAtom),
33 + input.snapshot,
34 + );
35 + if (!keepMounted) beginPreviewSessionClose(input.threadRef, input.tabId);
36 const result = await input.closePreview({
37 environmentId: input.threadRef.environmentId,
38 input: { threadId: input.threadRef.threadId, tabId: input.tabId },
39 });
40 if (result._tag === "Failure") {
41 cancelPreviewSessionClose(input.threadRef, input.snapshot, input.tabId);
32 - } else if (input.snapshot) {
42 + return result;
43 + }
44 + if (keepMounted) beginPreviewSessionClose(input.threadRef, input.tabId);
45 + if (input.snapshot) {
46 useClosedViewStore.getState().remember({
47 kind: "browser",
48 threadRef: input.threadRef,
apps/web/src/hooks/useRightPanelSurfaceClose.browser.test.tsx
+5
@@ -24,6 +24,11 @@ vi.mock("../previewStateStore", () => ({
24 beginPreviewSessionClose: () => {},
25 cancelPreviewSessionClose: () => {},
26 }));
27 +vi.mock("../browser/previewRuntime", () => ({ rendersServerTabNatively: () => false }));
28 +vi.mock("../state/primaryEnvironment", async () => {
29 + const { Atom } = await import("effect/reactivity");
30 + return { primaryEnvironmentIdAtom: Atom.make(null) };
31 +});
32 vi.mock("../state/session", () => ({
33 useEnvironmentScope: (id: string) => fixture.allowed.has(id),
34 readEnvironmentScope: (id: string) => fixture.allowed.has(id),