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;