diff --git a/apps/desktop/src/preview/Manager.test.ts b/apps/desktop/src/preview/Manager.test.ts index 2091ff3c7f8f2..12ea33cc6fb43 100644 --- a/apps/desktop/src/preview/Manager.test.ts +++ b/apps/desktop/src/preview/Manager.test.ts @@ -1714,19 +1714,25 @@ describe("PreviewManager", () => { let audible = false; let audibleAfterFirstRead = false; let audibleReads = 0; + let destroyed = false; return { setAudioMuted, emitAudioState: (next: boolean) => { audible = next; listeners.get("audio-state-changed")?.({ audible: next } as never); }, + /** Electron destroys a guest without a final audio-state change. */ + destroy: () => { + destroyed = true; + listeners.get("destroyed")?.(); + }, /** Simulate playback starting during attach before the tab owns the guest and can receive its events. */ startPlayingAfterFirstRead: () => { audibleAfterFirstRead = true; }, wc: { id, - isDestroyed: () => false, + isDestroyed: () => destroyed, isDevToolsOpened: () => false, getType: () => "webview", getURL: () => "https://example.com", @@ -1747,6 +1753,9 @@ describe("PreviewManager", () => { off: vi.fn((event: string) => { listeners.delete(event); }), + once: vi.fn((event: string, listener: (...args: never[]) => void) => { + listeners.set(event, listener); + }), ipc: { on: vi.fn(), off: vi.fn() }, send: webviewSend, navigationHistory: { canGoBack: () => false, canGoForward: () => false }, @@ -1816,6 +1825,33 @@ describe("PreviewManager", () => { ), ); + effectIt.effect("stops showing sound for a tab whose guest was destroyed", () => + withManager((manager) => + Effect.gen(function* () { + const guest = makeAudioWebContents(42); + fromId.mockReturnValue(guest.wc); + const states: PreviewManager.PreviewTabState[] = []; + + yield* manager.subscribeStateChanges((_tabId, state) => + Effect.sync(() => { + states.push(state); + }), + ); + yield* manager.prepareWebview(guest.wc); + yield* manager.createTab("tab_audio_destroyed"); + yield* manager.registerWebview("tab_audio_destroyed", 42); + guest.emitAudioState(true); + yield* Effect.yieldNow; + expect(states.at(-1)?.audible).toBe(true); + + guest.destroy(); + yield* Effect.yieldNow; + + expect(states.at(-1)).toMatchObject({ tabId: "tab_audio_destroyed", audible: false }); + }), + ), + ); + effectIt.effect("blocks late webview and capture starts during tab close", () => withManager((manager) => Effect.gen(function* () { diff --git a/apps/desktop/src/preview/Manager.ts b/apps/desktop/src/preview/Manager.ts index 32ac876996c81..ea24319a69506 100644 --- a/apps/desktop/src/preview/Manager.ts +++ b/apps/desktop/src/preview/Manager.ts @@ -2646,8 +2646,8 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function if (serverTab) browserHost.setCaptureDrawn(serverTab, drawn); }); - // A window reload or guest crash destroys the guest without the renderer reporting it hidden. - // The renderer reports again once a new guest registers. + // A window reload, guest crash or discarded hidden tab destroys the guest without the renderer + // reporting it hidden or Chromium reporting it silent. Both report again for the next guest. const hideDestroyedGuest = Effect.fnUntraced(function* (webContentsId: number) { for (const tab of (yield* SynchronizedRef.get(tabsRef)).values()) { if (tab.webContentsId === webContentsId && tab.serverTab) { @@ -2655,6 +2655,21 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function browserHost.setCaptureDrawn(tab.serverTab, false); } } + const updatedAt = yield* currentIso; + const silenced = yield* SynchronizedRef.modify(tabsRef, (tabs) => { + const tab = [...tabs.values()].find( + (candidate) => candidate.webContentsId === webContentsId && candidate.audible, + ); + if (!tab) return [Option.none(), tabs] as const; + const state: PreviewTabState = { ...tab, audible: false, updatedAt }; + return [ + Option.some(state), + replaceMap(tabs, (copy) => { + copy.set(tab.tabId, state); + }), + ] as const; + }); + if (Option.isSome(silenced)) yield* emitIfCurrent(silenced.value.tabId, silenced.value); }); const setAudioMuted = Effect.fn("PreviewManager.setAudioMuted")(function* ( diff --git a/apps/server/src/preview/ServerBrowser.test.ts b/apps/server/src/preview/ServerBrowser.test.ts index 46a28b26aa8b9..584befedf5c30 100644 --- a/apps/server/src/preview/ServerBrowser.test.ts +++ b/apps/server/src/preview/ServerBrowser.test.ts @@ -3848,7 +3848,7 @@ it.effect("failed session and browser launches release capacity, as does closing ).pipe(Effect.provide(layer)), ); -it.effect("a full server takes back the slot of the longest idle agent tab nobody views", () => +it.effect("agent tabs the desktop renders close once hidden and idle, without another open", () => Effect.scoped( Effect.gen(function* () { const broker = yield* Broker.PreviewAutomationBroker; @@ -3857,116 +3857,40 @@ it.effect("a full server takes back the slot of the longest idle agent tab nobod yield* Effect.yieldNow; const now = vi.spyOn(Date, "now").mockReturnValue(0); yield* Effect.addFinalizer(() => Effect.sync(() => now.mockRestore())); - const open = (providerSessionId: string) => { + const opened: Array = []; + for (let index = 0; index < 3; index++) { desktopRendersNext = true; - return broker.invoke({ - scope: asSession(providerSessionId), + const status = yield* broker.invoke({ + scope: asSession(`agent-${index}`), operation: "open", input: { reuseExistingTab: false, open: false }, }); - }; - const opened: Array = []; - for (let index = 0; index < 32; index++) { - now.mockReturnValue(index); - opened.push((yield* open(`agent-${Math.floor(index / 8)}`)).tabId!); + opened.push(status.tabId!); } + shownDesktopTabs.add(opened[1]!); + const openTabIds = () => + manager + .list({ threadId: scope.thread.threadId }) + .pipe(Effect.map(({ sessions }) => sessions.map((session) => session.tabId).toSorted())); + const sweepAt = (minutes: number) => { + now.mockReturnValue(minutes * 60 * 1000); + return TestClock.adjust("1 minute"); + }; - now.mockReturnValue(100); - yield* broker.invoke({ - scope: asSession("agent-observer"), - operation: "status", - tabId: PreviewTabId.make(opened[0]!), - input: {}, - }); + yield* sweepAt(29); + expect(yield* openTabIds()).toEqual(opened.toSorted()); - // Inside the idle window every desktop tab keeps its slot. - now.mockReturnValue(29 * 60 * 1000); - expect(yield* open("agent-new").pipe(Effect.flip)).toMatchObject({ reason: "tabLimit" }); - expect(releasedDesktopTabs).toEqual([]); - - now.mockReturnValue(31 * 60 * 1000); - // A session at its own limit couldn't use a freed slot, so nothing closes for it. - expect(yield* open("agent-3").pipe(Effect.flip)).toMatchObject({ reason: "tabLimit" }); - expect(releasedDesktopTabs).toEqual([]); - // Tabs a desktop window shows keep their slots however long they sit idle. - for (const tabId of opened) shownDesktopTabs.add(tabId); - expect(yield* open("agent-new").pipe(Effect.flip)).toMatchObject({ reason: "tabLimit" }); - expect(releasedDesktopTabs).toEqual([]); - shownDesktopTabs.clear(); - shownDesktopTabs.add(opened[1]!); - desktopConnections[2]!.context.page.beforeUnload = "listen"; - const events = yield* manager.subscribeEvents; - const releases = yield* Queue.unbounded(); - const recordRelease = (tabId: string) => Queue.offerUnsafe(releases, tabId); - desktopDetaches.on("release", recordRelease); - yield* Effect.addFinalizer(() => - Effect.sync(() => desktopDetaches.off("release", recordRelease)), - ); - const fresh = yield* open("agent-new"); - expect(fresh.tabId).toBeDefined(); - expect(yield* Queue.take(releases)).toBe(opened[2]); - expect(desktopConnections[2]!.context.page.unloadEvents).toEqual([ - "beforeunload", - "pagehide", - "visibilitychange", - ]); - yield* Stream.fromSubscription(events).pipe( - Stream.filter((event) => event.type === "closed" && event.tabId === opened[2]), - Stream.runHead, - ); - expect(releasedDesktopTabs).toEqual([opened[2]]); - const { sessions } = yield* manager.list({ threadId: scope.thread.threadId }); - expect(sessions.map((session) => session.tabId).toSorted()).toEqual( - [...opened.filter((tabId) => tabId !== opened[2]), fresh.tabId!].toSorted(), - ); + yield* sweepAt(31); + expect(releasedDesktopTabs.toSorted()).toEqual([opened[0], opened[2]].toSorted()); + // A shown tab keeps its guest however long the agent leaves it alone. + expect(yield* openTabIds()).toEqual([opened[1]]); - // A second open must reclaim a different tab while the first page is unloading. - const closingPage = desktopConnections[3]!.context.page; - closingPage.beforeUnload = "listen"; - closingPage.unloadGate = Promise.withResolvers(); - const closeRequests = yield* Queue.unbounded(); - const close = manager.close; - const closeSpy = vi - .spyOn(manager, "close") - .mockImplementation((input) => - Queue.offer(closeRequests, undefined).pipe(Effect.andThen(close(input))), - ); - yield* Effect.addFinalizer(() => Effect.sync(() => closeSpy.mockRestore())); - const firstOpen = yield* open("agent-concurrent").pipe(Effect.forkScoped); - yield* Queue.take(closeRequests); - yield* Effect.promise(() => closingPage.pagehideWatched.promise); - const secondOpen = yield* open("agent-concurrent").pipe(Effect.forkScoped); - yield* Queue.take(closeRequests); - closingPage.unloadGate.resolve(); - const concurrent = yield* Effect.all([Fiber.join(firstOpen), Fiber.join(secondOpen)]); - expect(concurrent.every((status) => status.available)).toBe(true); - const remaining = (yield* manager.list({ threadId: scope.thread.threadId })).sessions; - expect(remaining).toHaveLength(32); - const closedBeforeReturn = yield* Deferred.make(); - const finishClose = yield* Deferred.make(); - let heldClose = false; - closeSpy.mockImplementation((input) => { - const hold = !heldClose; - heldClose = true; - return close(input).pipe( - Effect.andThen( - hold - ? Deferred.succeed(closedBeforeReturn, undefined).pipe( - Effect.andThen(Deferred.await(finishClose)), - ) - : Effect.void, - ), - ); - }); - const reclaimingOpen = yield* open("agent-reclaiming").pipe(Effect.forkScoped); - yield* Deferred.await(closedBeforeReturn); - const takingFreedSlot = yield* open("agent-taking-free-slot"); - expect(takingFreedSlot.available).toBe(true); - yield* Deferred.succeed(finishClose, undefined); - expect((yield* Fiber.join(reclaimingOpen)).available).toBe(true); - expect((yield* manager.list({ threadId: scope.thread.threadId })).sessions).toHaveLength(32); - expect(remaining.some((session) => session.tabId === opened[3])).toBe(false); - expect(remaining.some((session) => session.tabId === opened[4])).toBe(false); + // Its idle window starts when it was last on screen, not when the agent last used it. + shownDesktopTabs.delete(opened[1]!); + yield* sweepAt(60); + expect(yield* openTabIds()).toEqual([opened[1]]); + yield* sweepAt(62); + expect(yield* openTabIds()).toEqual([]); }), ).pipe(Effect.provide(layer)), ); diff --git a/apps/server/src/preview/ServerBrowser.ts b/apps/server/src/preview/ServerBrowser.ts index 8d4e6080daa49..ec76146cd29c0 100644 --- a/apps/server/src/preview/ServerBrowser.ts +++ b/apps/server/src/preview/ServerBrowser.ts @@ -1783,58 +1783,23 @@ const make = Effect.gen(function* () { const isVisible = (tab: ServerTab) => tab.viewers.size > 0 || (tab.desktop !== null && desktopChannel.isShown(tab)); - const reclaimingTabs = new Set(); const idleAgentTabs = () => { const cutoff = Date.now() - AGENT_TAB_IDLE_MS; return [...tabs.values()].filter( - (tab) => - tab.control.agentId !== null && - !reclaimingTabs.has(tab) && - !isVisible(tab) && - tab.usedAt < cutoff, + (tab) => tab.control.agentId !== null && !isVisible(tab) && tab.usedAt < cutoff, ); }; - // The desktop app renders every server tab, so idle desktop agent tabs would otherwise - // hold the server's budget forever. Hidden ones give up their slots, longest idle first, - // only when an agent needs one and has room for it. - const freeIdleAgentSlot = async (agentSessionId: string) => { - if (!serverAtTabLimit() || agentAtTabLimit(agentSessionId)) return; - const longestIdle = idleAgentTabs().sort((left, right) => left.usedAt - right.usedAt)[0]; - if (longestIdle) { - reclaimingTabs.add(longestIdle); - try { - await runPromise( - manager.close({ threadId: longestIdle.threadId, tabId: longestIdle.tabId }), - ); - dropTab(longestIdle, false); - } finally { - reclaimingTabs.delete(longestIdle); - } - } - }; - // A Playwright launch must settle before its capacity can be released. const openTab = Effect.fn("ServerBrowser.openTab")(function* ( input: Parameters[0], - options: { readonly reclaimIdleSlot?: boolean } = {}, ) { let key: string = NodeCrypto.randomUUID(); const reservation = { agentId: input.automationOwner ?? null }; return yield* Effect.acquireUseRelease( Effect.tryPromise({ try: async () => { - if (input.automationOwner !== undefined) { - while ( - options.reclaimIdleSlot && - serverAtTabLimit() && - !agentAtTabLimit(input.automationOwner) && - idleAgentTabs().length > 0 - ) { - await freeIdleAgentSlot(input.automationOwner); - } - assertTabCapacity(input.automationOwner); - } + if (input.automationOwner !== undefined) assertTabCapacity(input.automationOwner); pendingTabs.set(key, reservation); }, catch: ServerBrowserPage.toOperationError, @@ -1871,10 +1836,12 @@ const make = Effect.gen(function* () { ); }, Effect.uninterruptible); - // Desktop browsing bypasses streamed viewers and server input tracking, - // so these idle signals only apply to headless tabs. + // Desktop browsing bypasses server input tracking, so a shown tab counts as used; the idle + // window then starts when it was last on screen, and hidden desktop guests do not live forever. const closeIdleAgentTabs = () => { - for (const tab of idleAgentTabs()) if (tab.desktop === null) dropTab(tab, true); + const now = Date.now(); + for (const tab of tabs.values()) if (isVisible(tab)) tab.usedAt = now; + for (const tab of idleAgentTabs()) dropTab(tab, true); }; const latestThreadTab = (threadId: string, agentSessionId?: string) => { @@ -2590,17 +2557,14 @@ const make = Effect.gen(function* () { const tab = existing ?? (await runPromise( - openTab( - { - threadId: request.threadId, - ...(url ? { url } : {}), - ...(profileId === undefined ? {} : { profileId }), - runtime: "server", - reveal: false, - automationOwner: request.agentSessionId, - }, - { reclaimIdleSlot: true }, - ), + openTab({ + threadId: request.threadId, + ...(url ? { url } : {}), + ...(profileId === undefined ? {} : { profileId }), + runtime: "server", + reveal: false, + automationOwner: request.agentSessionId, + }), )); if (existing?.dialog) throw new BrowserControlInterrupted({ diff --git a/apps/web/src/browser/ElectronBrowserHost.browser.test.tsx b/apps/web/src/browser/ElectronBrowserHost.browser.test.tsx index 29c217e064adc..e5ee0d08009f8 100644 --- a/apps/web/src/browser/ElectronBrowserHost.browser.test.tsx +++ b/apps/web/src/browser/ElectronBrowserHost.browser.test.tsx @@ -51,28 +51,55 @@ vi.mock(import("~/components/preview/usePreviewBridge"), async (original) => ({ usePreviewBridge: () => undefined, })); +// Stands in for a primary environment, whose server tabs the desktop renders natively. +vi.mock(import("./previewRuntime"), async (original) => ({ + ...(await original()), + rendersServerTabNatively: (_environmentId, _primaryEnvironmentId, snapshot) => + snapshot?.runtime === "server", +})); + import { __resetClientSettingsPersistenceForTests, ensureClientSettingsHydrated, } from "~/hooks/useSettings"; import { reconcilePreviewServerSessions, resetPreviewStateForTests } from "~/previewStateStore"; import { AppAtomRegistryProvider } from "~/rpc/atomRegistry"; +import { acquireBrowserSurface, useBrowserSurfaceStore } from "./browserSurfaceStore"; import { ElectronBrowserHost } from "./ElectronBrowserHost"; +import { previewRuntimeTabId } from "./previewRuntimeTabId"; const threadRef = scopeThreadRef( EnvironmentId.make("host-webview-order"), ThreadId.make("thread-webview-order"), ); -const snapshot = (tabId: string, updatedAt: string): PreviewSessionSnapshot => ({ +const snapshot = ( + tabId: string, + updatedAt: string, + overrides: Partial = {}, +): PreviewSessionSnapshot => ({ threadId: threadRef.threadId, tabId, - navStatus: { _tag: "Success", url: `https://example.com/${tabId}`, title: tabId }, + navStatus: { _tag: "Loading", url: `https://example.com/${tabId}`, title: tabId }, canGoBack: false, canGoForward: false, updatedAt, + ...overrides, +}); + +const loaded = (url: string) => ({ + navStatus: { _tag: "Success" as const, url, title: url }, }); +const PANEL_RECT = { x: 0, y: 0, width: 800, height: 600 }; + +/** Shows the tab in a visible preview panel; setup() clears it. */ +function showTab(tabId: string) { + const surface = acquireBrowserSurface(previewRuntimeTabId(threadRef, "server-a", tabId)); + surface.present(PANEL_RECT, true); + return surface; +} + function setup(): Disposable { __resetClientSettingsPersistenceForTests(); mocks.getClientSettings.mockReset().mockResolvedValue(DEFAULT_CLIENT_SETTINGS); @@ -88,6 +115,7 @@ function setup(): Disposable { return { [Symbol.dispose]() { resetPreviewStateForTests(); + useBrowserSurfaceStore.setState({ byTabId: {}, activityByTabId: {} }); __resetClientSettingsPersistenceForTests(); }, }; @@ -160,4 +188,62 @@ describe("ElectronBrowserHost", () => { expect(after).toHaveLength(2); expect(after.every((node, index) => node.isSameNode(before[index]!))).toBe(true); }); + + it("drops a hidden desktop tab's guest after ten minutes and reloads its page when shown", async () => { + using _state = setup(); + reconcilePreviewServerSessions(threadRef, { + sessions: [ + snapshot("tab_desktop", "2026-01-01T00:00:01.000Z"), + snapshot("tab_agent_1", "2026-01-01T00:00:02.000Z", { runtime: "server" }), + ], + serverEpoch: "server-a", + revision: 1, + }); + await using screen = await renderHost(); + const guestOf = (tabId: string) => + screen.container.querySelector(`webview[data-preview-server-tab="${tabId}"]`); + const panel = await act(() => showTab("tab_desktop")); + using _timers = fakeTimers(); + await act(() => panel.present(PANEL_RECT, false)); + const firstGuest = guestOf("tab_desktop"); + expect(firstGuest).not.toBeNull(); + + await act(() => vi.advanceTimersByTimeAsync(10 * 60_000 - 1)); + expect(guestOf("tab_desktop")).toBe(firstGuest); + await act(() => vi.advanceTimersByTimeAsync(1)); + expect(guestOf("tab_desktop")).toBeNull(); + // The agent's server tab is the server browser's to close. + expect(guestOf("tab_agent_1")).not.toBeNull(); + + await act(() => { + reconcilePreviewServerSessions(threadRef, { + sessions: [ + snapshot("tab_desktop", "2026-01-01T00:00:03.000Z", loaded("https://example.com/next")), + snapshot("tab_agent_1", "2026-01-01T00:00:02.000Z", { runtime: "server" }), + ], + serverEpoch: "server-a", + revision: 2, + }); + panel.present(PANEL_RECT, true); + }); + expect(guestOf("tab_desktop")?.getAttribute("src")).toBe("https://example.com/next"); + }); + + it("waits until a hidden tab whose page already loaded is shown to load it", async () => { + using _state = setup(); + reconcilePreviewServerSessions(threadRef, { + sessions: [ + snapshot("tab_loaded", "2026-01-01T00:00:01.000Z", loaded("https://example.com/loaded")), + ], + serverEpoch: "server-a", + revision: 1, + }); + await using screen = await renderHost(); + const guest = () => + screen.container.querySelector('webview[data-preview-server-tab="tab_loaded"]'); + expect(guest()).toBeNull(); + + await act(() => showTab("tab_loaded")); + expect(guest()?.getAttribute("src")).toBe("https://example.com/loaded"); + }); }); diff --git a/apps/web/src/browser/ElectronBrowserHost.tsx b/apps/web/src/browser/ElectronBrowserHost.tsx index d71b7a2b6b2ba..2aa3583c05083 100644 --- a/apps/web/src/browser/ElectronBrowserHost.tsx +++ b/apps/web/src/browser/ElectronBrowserHost.tsx @@ -143,6 +143,9 @@ export function ElectronBrowserHost() { tabId={snapshot.tabId} runtimeTabId={runtimeTabId} initialUrl={url} + initialUrlLoaded={ + snapshot.navStatus._tag === "Success" || snapshot.navStatus._tag === "LoadFailed" + } viewport={snapshot.viewport ?? FILL_PREVIEW_VIEWPORT} pictureInPicture={pictureInPicture} profileId={snapshot.profileId} diff --git a/apps/web/src/browser/HostedBrowserWebview.tsx b/apps/web/src/browser/HostedBrowserWebview.tsx index 023fb03c3aa17..5f60833586e17 100644 --- a/apps/web/src/browser/HostedBrowserWebview.tsx +++ b/apps/web/src/browser/HostedBrowserWebview.tsx @@ -36,6 +36,9 @@ import { type WebviewCrashRecoveryState, } from "./webviewCrashRecovery"; +// Showing a discarded tab reloads its page, so it trades in-page state for the guest's memory. +const HIDDEN_GUEST_DISCARD_MS = 10 * 60_000; + interface ElectronWebview extends HTMLElement { src: string; partition: string; @@ -56,6 +59,8 @@ export function HostedBrowserWebview(props: { readonly tabId: string; readonly runtimeTabId: string; readonly initialUrl: string | null; + /** An earlier guest finished loading `initialUrl`, so a hidden tab can wait to load it again. */ + readonly initialUrlLoaded: boolean; readonly viewport: PreviewViewportSetting; readonly pictureInPicture: boolean; /** Fixed for the tab lifetime; Electron reads partition before guest attachment. */ @@ -72,6 +77,7 @@ export function HostedBrowserWebview(props: { tabId, runtimeTabId, initialUrl, + initialUrlLoaded, viewport, pictureInPicture, zoomFactor, @@ -142,12 +148,33 @@ export function HostedBrowserWebview(props: { const [recoverySrc, setRecoverySrc] = useState(initialSrc); const active = presentation.visible && presentation.rect !== null; const shown = active || pictureInPicture; + const renderingActive = active || backgroundActivity || pictureInPicture || recordingActive; + // Server tabs are the agent's, and the server browser already closes the idle ones. + const discardable = !serverDriven && !renderingActive; + const [guestDiscarded, setGuestDiscarded] = useState( + () => discardable && initialUrl !== null && initialUrlLoaded, + ); + if (guestDiscarded && !discardable) { + setGuestDiscarded(false); + setRecoverySrc(initialUrl ?? initialSrc); + setWebviewGeneration((generation) => generation + 1); + } const reportedShown = useEffectEvent(() => serverDriven && shown); const remountCrashedWebview = useEffectEvent(() => { setRecoverySrc(initialUrl ?? initialSrc); setWebviewGeneration((generation) => generation + 1); }); + // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- drops the guest's renderer once the tab has stayed hidden for the idle window + useEffect(() => { + if (!discardable || guestDiscarded) return; + const timeout = window.setTimeout(() => { + setGuestDiscarded(true); + setWebviewGeneration((generation) => generation + 1); + }, HIDDEN_GUEST_DISCARD_MS); + return () => window.clearTimeout(timeout); + }, [discardable, guestDiscarded]); + const setWebviewRef = (node: HTMLElement | null) => { webviewRef.current = node as ElectronWebview | null; }; @@ -331,7 +358,7 @@ export function HostedBrowserWebview(props: { }; }, [clientSettingsHydrated, fullDetail, runtimeTabId, serverDriven]); - if (!clientSettingsHydrated || !config) return null; + if (!clientSettingsHydrated || !config || guestDiscarded) return null; // This fixed wrapper sits outside the right panel shell, so it takes thumb presses itself. const navigateThumb = (direction: "back" | "forward") => { @@ -339,7 +366,6 @@ export function HostedBrowserWebview(props: { else void previewBridge?.goForward(runtimeTabId); }; - const renderingActive = active || backgroundActivity || pictureInPicture || recordingActive; const viewportTransform = resolveBrowserViewportTransform(layout.viewportScale, fullDetail); const wrapperStyle = resolveHostedBrowserWebviewWrapperStyle({ active,