Skip to content

Commit 4332ed4

Browse files
fix(server): a closing desktop preview tab finishes unloading before its webview is removed
AI-assisted; verified with the tests and tools listed above.
1 parent 8de5a4f commit 4332ed4

2 files changed

Lines changed: 61 additions & 29 deletions

File tree

‎apps/server/src/preview/ServerBrowser.test.ts‎

Lines changed: 30 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -235,11 +235,20 @@ function makeContext(onClose?: (context: BrowserContext) => void, initialUrl = "
235235
// Set to hold the page open after `beforeunload` until resolved, as Playwright's
236236
// `runBeforeUnload` close resolves before the page actually closes.
237237
unloadGate: null as PromiseWithResolvers<void> | null,
238+
removed: false,
239+
pagehideBinding: null as (() => void) | null,
240+
pagehideWatched: Promise.withResolvers<void>(),
241+
exposeFunction: vi.fn(async (_name: string, callback: () => void) => {
242+
page.pagehideBinding = callback;
243+
page.pagehideWatched.resolve();
244+
}),
238245
close: vi.fn(async (options?: { runBeforeUnload?: boolean }) => {
239246
if (closed) return;
240247
const finish = () => {
241-
if (closed) return;
242-
page.unloadEvents.push("pagehide", "visibilitychange");
248+
if (closed || page.removed) return;
249+
page.unloadEvents.push("pagehide");
250+
page.pagehideBinding?.();
251+
page.unloadEvents.push("visibilitychange");
243252
closed = true;
244253
events.emit("close");
245254
};
@@ -1150,10 +1159,11 @@ it.live("closing a tab force-closes a page that never finishes unloading", () =>
11501159
).pipe(Effect.provide(layer)),
11511160
);
11521161

1153-
it.live("closing a desktop tab unloads its page before the desktop removes it", () =>
1162+
it.live("closing a desktop tab waits for its page to unload before the desktop removes it", () =>
11541163
Effect.scoped(
11551164
Effect.gen(function* () {
11561165
const { broker } = yield* ready;
1166+
const manager = yield* Manager.PreviewManager;
11571167
desktopRendersNext = true;
11581168
const opened = yield* broker.invoke<PreviewAutomationStatus>({
11591169
scope,
@@ -1163,15 +1173,28 @@ it.live("closing a desktop tab unloads its page before the desktop removes it",
11631173
const tabId = PreviewTabId.make(opened.tabId!);
11641174
const { context, browser } = desktopConnections[0]!;
11651175
const page = context.page;
1176+
// The desktop removes the webview once the session closes, dropping an unload in progress.
1177+
const events = yield* manager.subscribeEvents;
1178+
const sessionClosed = Promise.withResolvers<void>();
1179+
yield* Effect.gen(function* () {
1180+
while ((yield* PubSub.take(events)).type !== "closed");
1181+
page.removed = true;
1182+
sessionClosed.resolve();
1183+
}).pipe(Effect.forkScoped);
11661184
page.beforeUnload = "listen";
11671185
page.unloadGate = Promise.withResolvers<void>();
1168-
yield* broker.invoke({ scope, tabId, operation: "close", input: {} });
1169-
expect(page.unloadEvents).toEqual(["beforeunload"]);
1186+
const closing = yield* broker
1187+
.invoke({ scope, tabId, operation: "close", input: {} })
1188+
.pipe(Effect.forkScoped);
1189+
// The page finishes unloading once the server listens for it, or too late if it never does.
1190+
yield* Effect.promise(() =>
1191+
Promise.race([page.pagehideWatched.promise, sessionClosed.promise]),
1192+
);
11701193
expect(browser.close).not.toHaveBeenCalled();
11711194
page.unloadGate.resolve();
1172-
yield* Effect.promise(() => desktopReleased.promise);
1173-
expect(browser.close).toHaveBeenCalledTimes(1);
1195+
yield* Fiber.join(closing);
11741196
expect(page.unloadEvents).toEqual(["beforeunload", "pagehide", "visibilitychange"]);
1197+
expect(browser.close).toHaveBeenCalledTimes(1);
11751198
}),
11761199
).pipe(Effect.provide(layer)),
11771200
);

‎apps/server/src/preview/ServerBrowser.ts‎

Lines changed: 31 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -743,6 +743,28 @@ const make = Effect.gen(function* () {
743743

744744
const sessionOpen = (tab: ServerTab) => !closedSessions.has(tabKey(tab.threadId, tab.tabId));
745745

746+
// Closing the session makes the desktop destroy its webview, which drops an unload still in
747+
// progress, and `runBeforeUnload` resolves before it runs. So wait for the page's `pagehide`.
748+
const unloadDesktopPage = async (page: Page) => {
749+
const unloaded = Promise.withResolvers<void>();
750+
const timeout = setTimeout(unloaded.resolve, PAGE_CLOSE_GRACE_MS);
751+
const binding = `__t3PreviewUnloaded${NodeCrypto.randomUUID().replaceAll("-", "")}`;
752+
void (async () => {
753+
await page.exposeFunction(binding, unloaded.resolve);
754+
await page.evaluate((name) => {
755+
const target = globalThis as unknown as {
756+
addEventListener: (type: string, listener: () => void) => void;
757+
};
758+
target.addEventListener("pagehide", () =>
759+
Reflect.apply(Reflect.get(target, name), target, []),
760+
);
761+
}, binding);
762+
await page.close({ runBeforeUnload: true });
763+
})().catch(unloaded.resolve);
764+
await unloaded.promise;
765+
clearTimeout(timeout);
766+
};
767+
746768
const dropTab = (tab: ServerTab, closeSession: boolean) => {
747769
const key = tabKey(tab.threadId, tab.tabId);
748770
if (tabs.get(key) !== tab) return;
@@ -753,26 +775,14 @@ const make = Effect.gen(function* () {
753775
const end = tab.desktop && !closeSession && sessionOpen(tab) ? "reconnect" : "gone";
754776
for (const viewer of tab.viewers) viewer.push({ _tag: end });
755777
void tab.control.close().catch(constVoid);
756-
const page = tab.page;
757-
// `runBeforeUnload` returns before the page closes, so closing an isolated context
758-
// must wait for it. A pending dialog would block `beforeunload` from running at all.
759-
const closed = page.isClosed()
760-
? Promise.resolve()
761-
: new Promise<void>((resolve) => page.once("close", () => resolve()));
762-
if (tab.desktop) {
763-
const desktop = tab.desktop;
764-
if (end === "reconnect") void desktop.close().catch(constVoid);
765-
else {
766-
// Stay connected while the departing page unloads, so its close-time guard is accepted.
767-
const grace = new Promise<void>((resolve) => {
768-
const timeout = setTimeout(resolve, PAGE_CLOSE_GRACE_MS);
769-
void closed.then(() => clearTimeout(timeout));
770-
});
771-
void Promise.race([closed, grace])
772-
.then(() => desktop.close())
773-
.catch(constVoid);
774-
}
775-
} else {
778+
if (tab.desktop) void tab.desktop.close().catch(constVoid);
779+
else {
780+
const page = tab.page;
781+
// `runBeforeUnload` returns before the page closes, so closing an isolated context
782+
// must wait for it. A pending dialog would block `beforeunload` from running at all.
783+
const closed = page.isClosed()
784+
? Promise.resolve()
785+
: new Promise<void>((resolve) => page.once("close", () => resolve()));
776786
// A renderer that never finishes unloading would outlive its tab, so force it closed.
777787
const forceClose = setTimeout(() => void page.close().catch(constVoid), PAGE_CLOSE_GRACE_MS);
778788
void closed.then(() => clearTimeout(forceClose));
@@ -2186,10 +2196,9 @@ const make = Effect.gen(function* () {
21862196
reason: "humanControl",
21872197
});
21882198
void tab.control.close().catch(constVoid);
2189-
// Closing the session makes the desktop remove its webview without unloading the page.
21902199
if (tab.desktop && tab.dialog === null) {
21912200
tab.closing = true;
2192-
await tab.page.close({ runBeforeUnload: true }).catch(constVoid);
2201+
await unloadDesktopPage(tab.page);
21932202
}
21942203
await runPromise(manager.close({ threadId: tab.threadId, tabId: tab.tabId }));
21952204
dropTab(tab, false);

0 commit comments

Comments
 (0)