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),