@devries-cameron20 / t3code Mirror · read-only / commits / 9296c20e82
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 22, 17:00 UTC

refactor(web): browser panel tabs follow preview sessions without ChatView effects (#25006)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Oct 25, 2026 at 18:14 UTC 9296c20e82cef89371e2a4fb433f31c314384261
7 files changed +359 -96
apps/web/src/appInit.tsx
+2
@@ -3,6 +3,7 @@ import { createBrowserHistory, createHashHistory } from "@tanstack/react-router"
3
4 import { applyAppearanceContrast } from "./appearanceContrast";
5 import { applyAppearanceFontVariables } from "./appearanceFonts";
6 +import { startAgentOpenedPreviews } from "./components/preview/agentOpenedPreviews";
7 import { APP_BASE_NAME, APP_DISPLAY_NAME, APP_STAGE_LABEL } from "./branding";
8 import { resolveServerBackedAppDisplayName } from "./branding.logic";
9 import { isElectron } from "./env";
@@ -101,6 +102,7 @@ export function startAppServices(): AppRouter {
102
103 startClientAppearance();
104 startDocumentTitle();
105 + startAgentOpenedPreviews();
106
107 return router;
108 }
apps/web/src/components/ChatView.tsx
-32
@@ -934,7 +934,6 @@ export default function ChatView(props: ChatViewProps) {
934 );
935 const activePreviewState = useThreadPreviewState(activeThreadRef);
936 const activePreviewServerEpoch = activePreviewState.serverEpoch;
937 - const previewSessionsReady = !activeEnvironmentServerBrowser || activePreviewState.listLoaded;
937 const resolvePreviewRuntimeTabId = activeThreadRef
938 ? (tabId: string) => previewRuntimeTabId(activeThreadRef, activePreviewServerEpoch, tabId)
939 : undefined;
@@ -986,34 +985,6 @@ export default function ChatView(props: ChatViewProps) {
985 ),
986 );
987
989 - useEffect(() => {
990 - if (!activeThreadRef || !previewSessionsReady) return;
991 - const hiddenTabIds = new Set(
992 - Object.values(activePreviewState.sessions)
993 - .filter((session) => session.runtime === "server" && session.reveal === false)
994 - .map((session) => session.tabId),
995 - );
996 - useRightPanelStore
997 - .getState()
998 - .reconcileBrowserSurfaces(
999 - activeThreadRef,
1000 - Object.keys(activePreviewState.sessions),
1001 - hiddenTabIds,
1002 - );
1003 - }, [activePreviewState.sessions, activeThreadRef, previewSessionsReady]);
1004 -
1005 - useEffect(() => {
1006 - const source = activePreviewMiniPlayer?.source;
1007 - if (
1008 - activeThreadRef &&
1009 - previewSessionsReady &&
1010 - source?.kind === "browser" &&
1011 - !activePreviewState.sessions[source.tabId]
1012 - ) {
1013 - usePreviewMiniPlayerStore.getState().close(activeThreadRef);
1014 - }
1015 - }, [activePreviewMiniPlayer, activePreviewState.sessions, activeThreadRef, previewSessionsReady]);
1016 -
988 const latestRunSettled = isLatestRunSettled(activeLatestRun, activeRuntime);
989 const activePlan = deriveActivePlanState(serverProjection, activeActivityRun?.runId);
990 const activeActivityRunSettled = isLatestRunSettled(activeActivityRun, activeRuntime);
@@ -1893,9 +1864,6 @@ export default function ChatView(props: ChatViewProps) {
1864 threadRef: activeThreadRef,
1865 deviceState,
1866 deviceStateLoaded,
1896 - previewState: activePreviewState,
1897 - serverBrowserAvailable: activeEnvironmentServerBrowser,
1898 - panelSurfaces: rightPanelState.surfaces,
1867 miniPlayerSource: activePreviewMiniPlayer?.source ?? null,
1868 sheetLayout: shouldUsePlanSidebarSheet,
1869 });
apps/web/src/components/preview/agentOpenedPreviews.test.ts new
+108
@@ -0,0 +1,108 @@
1 +import { scopedThreadKey, scopeThreadRef } from "@t3tools/client-runtime/environment";
2 +import { type EnvironmentId, type PreviewSessionSnapshot, ThreadId } from "@t3tools/contracts";
3 +import { describe, expect, it, vi } from "vite-plus/test";
4 +
5 +import { browserMiniPlayerSource, usePreviewMiniPlayerStore } from "../../previewMiniPlayerStore";
6 +import { __testing as previewStateTesting } from "../../previewStateStore";
7 +import { useRightPanelStore } from "../../rightPanelStore";
8 +import { followPreviewSessions, revealServerTabs } from "./agentOpenedPreviews";
9 +
10 +vi.mock("../../state/entities", () => ({
11 + readEnvironmentSupportsServerBrowser: () => true,
12 +}));
13 +
14 +const ref = scopeThreadRef("env-1" as EnvironmentId, ThreadId.make("thread-1"));
15 +const threadKey = scopedThreadKey(ref);
16 +
17 +function setup() {
18 + usePreviewMiniPlayerStore.setState({ byThreadKey: {} });
19 + useRightPanelStore.setState({ byThreadKey: {} });
20 +}
21 +
22 +const miniPlayerSource = () => usePreviewMiniPlayerStore.getState().byThreadKey[threadKey]?.source;
23 +
24 +describe("revealServerTabs", () => {
25 + const tab = (tabId: string, force?: boolean): PreviewSessionSnapshot => ({
26 + threadId: "thread-1",
27 + tabId,
28 + navStatus: { _tag: "Loading", url: "http://localhost:5173/", title: "" },
29 + canGoBack: false,
30 + canGoForward: false,
31 + updatedAt: "2026-01-01T00:00:00.000Z",
32 + runtime: "server",
33 + reveal: true,
34 + ...(force === undefined ? {} : { revealRequest: { id: "r1", force } }),
35 + });
36 + const floatingTabId = () => {
37 + const source = miniPlayerSource();
38 + return source?.kind === "browser" ? source.tabId : null;
39 + };
40 +
41 + it("floats revealed tabs, and only forced ones when floating previews are off", () => {
42 + setup();
43 + revealServerTabs(ref, [tab("tab_plain")], { autoShowFloatingPreview: false });
44 + expect(floatingTabId()).toBeNull();
45 + revealServerTabs(ref, [tab("tab_forced", true)], { autoShowFloatingPreview: false });
46 + expect(floatingTabId()).toBe("tab_forced");
47 + });
48 +
49 + it("focuses a tab already in the panel instead of floating it when forced", () => {
50 + setup();
51 + useRightPanelStore.getState().openBrowser(ref, "tab_a");
52 + const browserSurfaceId = useRightPanelStore.getState().byThreadKey[threadKey]?.activeSurfaceId;
53 + useRightPanelStore.getState().open(ref, "diff");
54 +
55 + revealServerTabs(ref, [tab("tab_a", false)], { autoShowFloatingPreview: true });
56 + expect(useRightPanelStore.getState().byThreadKey[threadKey]?.activeSurfaceId).not.toBe(
57 + browserSurfaceId,
58 + );
59 + revealServerTabs(ref, [tab("tab_a", true)], { autoShowFloatingPreview: true });
60 + expect(useRightPanelStore.getState().byThreadKey[threadKey]?.activeSurfaceId).toBe(
61 + browserSurfaceId,
62 + );
63 + expect(floatingTabId()).toBeNull();
64 + });
65 +});
66 +
67 +describe("followPreviewSessions", () => {
68 + const snapshot = (tabId: string, reveal = true): PreviewSessionSnapshot => ({
69 + threadId: "thread-1",
70 + tabId,
71 + navStatus: { _tag: "Loading", url: "http://localhost:5173/", title: "" },
72 + canGoBack: false,
73 + canGoForward: false,
74 + updatedAt: "2026-01-01T00:00:00.000Z",
75 + runtime: "server",
76 + reveal,
77 + });
78 + const previewState = (sessions: ReadonlyArray<PreviewSessionSnapshot>, listLoaded = true) => ({
79 + ...previewStateTesting.EMPTY_THREAD_PREVIEW_STATE,
80 + listLoaded,
81 + sessions: Object.fromEntries(sessions.map((entry) => [entry.tabId, entry])),
82 + });
83 + const browserTabs = () =>
84 + useRightPanelStore
85 + .getState()
86 + .byThreadKey[threadKey]?.surfaces.filter((surface) => surface.kind === "preview")
87 + .map((surface) => surface.id);
88 +
89 + it("adds visible sessions as tabs and drops tabs whose session ended", () => {
90 + setup();
91 + useRightPanelStore.getState().openBrowser(ref, "tab_gone");
92 + followPreviewSessions(ref, previewState([snapshot("tab_a"), snapshot("tab_hidden", false)]));
93 + expect(browserTabs()).toEqual(["browser:tab_a"]);
94 + });
95 +
96 + it("waits for the first server list before treating missing sessions as closed", () => {
97 + setup();
98 + useRightPanelStore.getState().openBrowser(ref, "tab_a");
99 + usePreviewMiniPlayerStore.getState().open(ref, browserMiniPlayerSource("tab_a"));
100 + followPreviewSessions(ref, previewState([], false));
101 + expect(browserTabs()).toEqual(["browser:tab_a"]);
102 + expect(miniPlayerSource()).toMatchObject({ kind: "browser", tabId: "tab_a" });
103 +
104 + followPreviewSessions(ref, previewState([]));
105 + expect(browserTabs()).toEqual([]);
106 + expect(miniPlayerSource()).toBeUndefined();
107 + });
108 +});
apps/web/src/components/preview/agentOpenedPreviews.ts new
+74
@@ -0,0 +1,74 @@
1 +import { scopedThreadKey } from "@t3tools/client-runtime/environment";
2 +import type { PreviewSessionSnapshot, ScopedThreadRef } from "@t3tools/contracts";
3 +
4 +import { getClientSettings } from "../../hooks/useSettings";
5 +import { browserMiniPlayerSource, usePreviewMiniPlayerStore } from "../../previewMiniPlayerStore";
6 +import {
7 + onPreviewSessionsChanged,
8 + onServerTabsRevealed,
9 + type ThreadPreviewState,
10 +} from "../../previewStateStore";
11 +import { useRightPanelStore } from "../../rightPanelStore";
12 +import { readEnvironmentSupportsServerBrowser } from "../../state/entities";
13 +
14 +/**
15 + * Shows browsers an agent or another client revealed for a thread: floating
16 + * over chat, or focusing an existing panel tab when the reveal is forced.
17 + */
18 +export function revealServerTabs(
19 + threadRef: ScopedThreadRef,
20 + sessions: ReadonlyArray<PreviewSessionSnapshot>,
21 + options: { readonly autoShowFloatingPreview: boolean },
22 +): void {
23 + if (!readEnvironmentSupportsServerBrowser(threadRef.environmentId)) return;
24 + for (const session of sessions) {
25 + const force = session.revealRequest?.force === true;
26 + if (!options.autoShowFloatingPreview && !force) continue;
27 + const surface = useRightPanelStore
28 + .getState()
29 + .byThreadKey[scopedThreadKey(threadRef)]?.surfaces.find(
30 + (surface) => surface.kind === "preview" && surface.resourceId === session.tabId,
31 + );
32 + if (surface && force) {
33 + useRightPanelStore.getState().activateSurface(threadRef, surface.id);
34 + } else if (!surface) {
35 + usePreviewMiniPlayerStore.getState().open(threadRef, browserMiniPlayerSource(session.tabId));
36 + }
37 + }
38 +}
39 +
40 +/**
41 + * Keeps a thread's browser panel tabs and floating browser in step with its
42 + * preview sessions. Server-hosted sessions are only complete once the first
43 + * list has loaded; before that, a missing session is not a closed one.
44 + */
45 +export function followPreviewSessions(threadRef: ScopedThreadRef, state: ThreadPreviewState): void {
46 + if (readEnvironmentSupportsServerBrowser(threadRef.environmentId) && !state.listLoaded) return;
47 + const sessions = Object.values(state.sessions);
48 + useRightPanelStore.getState().reconcileBrowserSurfaces(
49 + threadRef,
50 + sessions.map((session) => session.tabId),
51 + new Set(
52 + sessions
53 + .filter((session) => session.runtime === "server" && session.reveal === false)
54 + .map((session) => session.tabId),
55 + ),
56 + );
57 + const miniPlayer = usePreviewMiniPlayerStore.getState();
58 + const source = miniPlayer.byThreadKey[scopedThreadKey(threadRef)]?.source;
59 + if (source?.kind === "browser" && !state.sessions[source.tabId]) miniPlayer.close(threadRef);
60 +}
61 +
62 +let started = false;
63 +
64 +/** Follows every thread's browser previews for the life of the page, not just the open thread's. */
65 +export function startAgentOpenedPreviews(): void {
66 + if (started) return;
67 + started = true;
68 + onPreviewSessionsChanged(followPreviewSessions);
69 + onServerTabsRevealed((threadRef, sessions) =>
70 + revealServerTabs(threadRef, sessions, {
71 + autoShowFloatingPreview: getClientSettings().browserAutoShowFloatingPreview,
72 + }),
73 + );
74 +}
apps/web/src/components/preview/useAgentOpenedPreviews.ts
+2 -56
@@ -3,12 +3,10 @@ import { scopedThreadKey } from "@t3tools/client-runtime/environment";
3 import { useEffect, useRef } from "react";
4 import { useClientSettings } from "../../hooks/useSettings";
5 import {
6 - browserMiniPlayerSource,
6 usePreviewMiniPlayerStore,
7 type PreviewMiniPlayerState,
8 } from "../../previewMiniPlayerStore";
10 -import type { ThreadPreviewState } from "../../previewStateStore";
11 -import { useRightPanelStore, type RightPanelSurface } from "../../rightPanelStore";
9 +import { useRightPanelStore } from "../../rightPanelStore";
10
11 const selectAutoShowFloatingPreview = (settings: { browserAutoShowFloatingPreview: boolean }) =>
12 settings.browserAutoShowFloatingPreview;
@@ -17,23 +15,11 @@ export function useAgentOpenedPreviews(input: {
15 readonly threadRef: ScopedThreadRef | null;
16 readonly deviceState: DeviceServiceState;
17 readonly deviceStateLoaded: boolean;
20 - readonly previewState: ThreadPreviewState;
21 - readonly serverBrowserAvailable: boolean;
22 - readonly panelSurfaces: ReadonlyArray<RightPanelSurface>;
18 readonly miniPlayerSource: PreviewMiniPlayerState["source"] | null;
19 // Sheet layouts show neither floating previews nor auto-opened device tabs.
20 readonly sheetLayout: boolean;
21 }) {
27 - const {
28 - threadRef,
29 - deviceState,
30 - deviceStateLoaded,
31 - previewState,
32 - serverBrowserAvailable,
33 - panelSurfaces,
34 - miniPlayerSource,
35 - sheetLayout,
36 - } = input;
22 + const { threadRef, deviceState, deviceStateLoaded, miniPlayerSource, sheetLayout } = input;
23 const autoShowFloatingPreview = useClientSettings(selectAutoShowFloatingPreview);
24 // Baseline sessions to preserve dismissals on reload; missing device summaries must remain eligible to open
25 // later.
@@ -88,46 +74,6 @@ export function useAgentOpenedPreviews(input: {
74 deviceState.sessions,
75 deviceState.devices,
76 ]);
91 - // Baseline loaded tabs so reloads never reopen previews the user dismissed.
92 - const previousServerPreviewTabs = useRef(new Map<string, Map<string, string | undefined>>());
93 - useEffect(() => {
94 - if (!threadRef || !serverBrowserAvailable || !previewState.listLoaded) return;
95 - const threadKey = scopedThreadKey(threadRef);
96 - const serverSessions = Object.values(previewState.sessions).filter(
97 - (session) => session.runtime === "server",
98 - );
99 - const previous = previousServerPreviewTabs.current.get(threadKey);
100 - previousServerPreviewTabs.current.set(
101 - threadKey,
102 - new Map(serverSessions.map((session) => [session.tabId, session.revealRequest?.id])),
103 - );
104 - if (!previous) return;
105 - for (const session of serverSessions) {
106 - const requested = session.revealRequest;
107 - const fresh = requested
108 - ? previous.get(session.tabId) !== requested.id
109 - : !previous.has(session.tabId);
110 - if (!fresh || session.reveal !== true) continue;
111 - if (!autoShowFloatingPreview && requested?.force !== true) continue;
112 - const surface = panelSurfaces.find(
113 - (surface) => surface.kind === "preview" && surface.resourceId === session.tabId,
114 - );
115 - if (surface && requested?.force === true) {
116 - useRightPanelStore.getState().activateSurface(threadRef, surface.id);
117 - } else if (!surface) {
118 - usePreviewMiniPlayerStore
119 - .getState()
120 - .open(threadRef, browserMiniPlayerSource(session.tabId));
121 - }
122 - }
123 - }, [
124 - serverBrowserAvailable,
125 - previewState.listLoaded,
126 - previewState.sessions,
127 - threadRef,
128 - autoShowFloatingPreview,
129 - panelSurfaces,
130 - ]);
77 useEffect(() => {
78 if (!threadRef || !deviceStateLoaded) return;
79 const source = miniPlayerSource;
apps/web/src/previewStateStore.test.ts
+74
@@ -19,6 +19,7 @@ import {
19 reconcilePreviewServerSessions,
20 resetPreviewStateForTests,
21 setActivePreviewTab,
22 + onServerTabsRevealed,
23 } from "./previewStateStore";
24 import { appAtomRegistry } from "./rpc/atomRegistry";
25
@@ -418,3 +419,76 @@ describe("previewStateStore (single-tab)", () => {
419 });
420 });
421 });
422 +
423 +describe("previewStateStore server reveals", () => {
424 + const collectReveals = () => {
425 + const tabIds: string[] = [];
426 + const stop = onServerTabsRevealed((_ref, sessions) => {
427 + tabIds.push(...sessions.map((session) => session.tabId));
428 + });
429 + return { tabIds, [Symbol.dispose]: stop };
430 + };
431 + const serverTab = (overrides: Partial<PreviewSessionSnapshot> = {}) =>
432 + makeSnapshot({ runtime: "server", reveal: true, ...overrides });
433 +
434 + it("treats the first list as a baseline and reveals tabs opened later", () => {
435 + using reveals = collectReveals();
436 + const revealed = reveals.tabIds;
437 + reconcilePreviewServerSessions(ref, {
438 + sessions: [serverTab({ tabId: "tab_restored" })],
439 + serverEpoch,
440 + revision: 1,
441 + });
442 + expect(revealed).toEqual([]);
443 +
444 + const opened = serverTab({ tabId: "tab_agent" });
445 + applyPreviewServerEvent(ref, {
446 + type: "opened",
447 + threadId: "thread-1",
448 + tabId: opened.tabId,
449 + createdAt: opened.updatedAt,
450 + snapshot: opened,
451 + });
452 + expect(revealed).toEqual(["tab_agent"]);
453 + });
454 +
455 + it("reveals an existing tab only for a new reveal request", () => {
456 + using reveals = collectReveals();
457 + const revealed = reveals.tabIds;
458 + const tab = serverTab({ revealRequest: { id: "r1", force: false } });
459 + reconcilePreviewServerSessions(ref, { sessions: [tab], serverEpoch, revision: 1 });
460 +
461 + const navigated = { ...tab, updatedAt: "2026-01-01T00:00:01.000Z" };
462 + applyPreviewServerEvent(ref, {
463 + type: "navigated",
464 + threadId: "thread-1",
465 + tabId: tab.tabId,
466 + createdAt: navigated.updatedAt,
467 + snapshot: navigated,
468 + });
469 + expect(revealed).toEqual([]);
470 +
471 + const requested = {
472 + ...navigated,
473 + revealRequest: { id: "r2", force: true },
474 + updatedAt: "2026-01-01T00:00:02.000Z",
475 + };
476 + applyPreviewServerEvent(ref, {
477 + type: "navigated",
478 + threadId: "thread-1",
479 + tabId: tab.tabId,
480 + createdAt: requested.updatedAt,
481 + snapshot: requested,
482 + });
483 + expect(revealed).toEqual([tab.tabId]);
484 + });
485 +
486 + it("never reveals tabs this client opened or desktop tabs", () => {
487 + using reveals = collectReveals();
488 + const revealed = reveals.tabIds;
489 + reconcilePreviewServerSessions(ref, { sessions: [], serverEpoch, revision: 1 });
490 + applyPreviewServerSnapshot(ref, serverTab({ tabId: "tab_own", reveal: undefined }));
491 + applyPreviewServerSnapshot(ref, makeSnapshot({ tabId: "tab_desktop", reveal: true }));
492 + expect(revealed).toEqual([]);
493 + });
494 +});
apps/web/src/previewStateStore.ts
+99 -8
@@ -98,20 +98,111 @@ function syncActivePreviewThread(threadKey: string, state: ThreadPreviewState):
98 });
99 }
100
101 -function updateThreadPreviewState(
101 +function writeThreadPreviewState(
102 ref: ScopedThreadRef,
103 update: (current: ThreadPreviewState) => ThreadPreviewState,
104 -): void {
104 +): { readonly previous: ThreadPreviewState; readonly next: ThreadPreviewState } | null {
105 const threadKey = scopedThreadKey(ref);
106 const atom = previewStateAtom(threadKey);
107 - let nextState = appAtomRegistry.get(atom);
107 + let previousState = appAtomRegistry.get(atom);
108 + let nextState = previousState;
109 const changed = appAtomRegistry.modify(atom, (current) => {
110 + previousState = current;
111 nextState = update(current);
112 return [nextState !== current, nextState];
113 });
112 - if (!changed) return;
114 + if (!changed) return null;
115 changedPreviewThreadKeys.add(threadKey);
116 syncActivePreviewThread(threadKey, nextState);
117 + return { previous: previousState, next: nextState };
118 +}
119 +
120 +/**
121 + * Server tabs that are new, or carry a new reveal request, since `previous`.
122 + * Nothing is fresh until the first list has loaded: that list is the baseline,
123 + * so a reload never reopens previews the user dismissed.
124 + */
125 +function freshlyRevealedServerTabs(
126 + previous: ThreadPreviewState,
127 + next: ThreadPreviewState,
128 +): ReadonlyArray<PreviewSessionSnapshot> {
129 + if (!previous.listLoaded) return [];
130 + return Object.values(next.sessions).filter((session) => {
131 + if (session.runtime !== "server" || session.reveal !== true) return false;
132 + const before = previous.sessions[session.tabId];
133 + const requested = session.revealRequest;
134 + return requested ? before?.revealRequest?.id !== requested.id : before === undefined;
135 + });
136 +}
137 +
138 +type PreviewSessionsChangedListener = (ref: ScopedThreadRef, next: ThreadPreviewState) => void;
139 +
140 +const previewSessionsChangedListeners = new Set<PreviewSessionsChangedListener>();
141 +
142 +/**
143 + * Panel tabs and the mini player follow the sessions held here. They live in
144 + * stores this one cannot import (rightPanelStore -> closedViewStore ->
145 + * lib/utils -> composerDraftStore -> previewStateStore is a cycle).
146 + */
147 +export function onPreviewSessionsChanged(listener: PreviewSessionsChangedListener): () => void {
148 + previewSessionsChangedListeners.add(listener);
149 + return () => {
150 + previewSessionsChangedListeners.delete(listener);
151 + };
152 +}
153 +
154 +function notifyPreviewSessionsChanged(
155 + ref: ScopedThreadRef,
156 + result: { readonly previous: ThreadPreviewState; readonly next: ThreadPreviewState },
157 +): void {
158 + if (
159 + result.previous.sessions === result.next.sessions &&
160 + result.previous.listLoaded === result.next.listLoaded
161 + ) {
162 + return;
163 + }
164 + for (const listener of previewSessionsChangedListeners) listener(ref, result.next);
165 +}
166 +
167 +function updateThreadPreviewState(
168 + ref: ScopedThreadRef,
169 + update: (current: ThreadPreviewState) => ThreadPreviewState,
170 +): void {
171 + const result = writeThreadPreviewState(ref, update);
172 + if (result) notifyPreviewSessionsChanged(ref, result);
173 +}
174 +
175 +type ServerTabsRevealedListener = (
176 + ref: ScopedThreadRef,
177 + sessions: ReadonlyArray<PreviewSessionSnapshot>,
178 +) => void;
179 +
180 +const serverTabsRevealedListeners = new Set<ServerTabsRevealedListener>();
181 +
182 +/**
183 + * Where a revealed tab shows depends on client settings, which this store
184 + * cannot import: lib/utils -> composerDraftStore -> previewStateStore ->
185 + * hooks/useSettings -> ui/toast -> lib/utils is a cycle.
186 + */
187 +export function onServerTabsRevealed(listener: ServerTabsRevealedListener): () => void {
188 + serverTabsRevealedListeners.add(listener);
189 + return () => {
190 + serverTabsRevealedListeners.delete(listener);
191 + };
192 +}
193 +
194 +function updateThreadPreviewStateFromServer(
195 + ref: ScopedThreadRef,
196 + update: (current: ThreadPreviewState) => ThreadPreviewState,
197 +): void {
198 + const result = writeThreadPreviewState(ref, update);
199 + if (!result) return;
200 + // Reveals run first so a revealed tab floats before it gains a panel tab.
201 + const revealed = freshlyRevealedServerTabs(result.previous, result.next);
202 + if (revealed.length > 0) {
203 + for (const listener of serverTabsRevealedListeners) listener(ref, revealed);
204 + }
205 + notifyPreviewSessionsChanged(ref, result);
206 }
207
208 const dedupeRecentUrls = (existing: string[], url: string): string[] => {
@@ -166,7 +257,7 @@ export function readThreadPreviewState(ref: ScopedThreadRef): ThreadPreviewState
257 }
258
259 export function applyPreviewServerEvent(ref: ScopedThreadRef, event: PreviewEvent): void {
169 - updateThreadPreviewState(ref, (current) => {
260 + updateThreadPreviewStateFromServer(ref, (current) => {
261 if (current.serverEpoch !== null && event.serverEpoch !== current.serverEpoch) return current;
262 if (event.revision < current.serverRevision) return current;
263 const next = (() => {
@@ -237,7 +328,7 @@ export function applyPreviewServerSnapshot(
328 ref: ScopedThreadRef,
329 snapshot: PreviewSessionSnapshot | null,
330 ): void {
240 - updateThreadPreviewState(ref, (current) => {
331 + updateThreadPreviewStateFromServer(ref, (current) => {
332 if (!snapshot && current.snapshot === null) return current;
333 if (!snapshot) {
334 return {
@@ -269,7 +360,7 @@ export function updatePreviewServerSnapshot(
360 ref: ScopedThreadRef,
361 snapshot: PreviewSessionSnapshot,
362 ): void {
272 - updateThreadPreviewState(ref, (current) => {
363 + updateThreadPreviewStateFromServer(ref, (current) => {
364 if (current.suppressedTabIds.has(snapshot.tabId)) return current;
365 const existing = current.sessions[snapshot.tabId];
366 if (existing && existing.updatedAt > snapshot.updatedAt) return current;
@@ -292,7 +383,7 @@ export function reconcilePreviewServerSessions(
383 ref: ScopedThreadRef,
384 result: PreviewListResult,
385 ): void {
295 - updateThreadPreviewState(ref, (current) => {
386 + updateThreadPreviewStateFromServer(ref, (current) => {
387 const sameServer = current.serverEpoch === result.serverEpoch;
388 if (sameServer && result.revision < current.serverRevision) {
389 return current;