The best way to control Claude Code, Codex and more from any computer or phone
refactor(web): preview tab sync subscribes to the preview store instead of its own listener sets (#25196)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Oct 25, 2026 at 18:49 UTC
b16728af846ab00903867737f80bbd4d75cf973d
4 files changed
+216
-192
apps/web/src/components/preview/agentOpenedPreviews.test.ts
+138
-2
@@ -3,9 +3,21 @@ import { type EnvironmentId, type PreviewSessionSnapshot, ThreadId } from "@t3to
3
import { describe, expect, it, vi } from "vite-plus/test";
4
5
import { browserMiniPlayerSource, usePreviewMiniPlayerStore } from "../../previewMiniPlayerStore";
6
-import { __testing as previewStateTesting } from "../../previewStateStore";
6
+import {
7
+ __testing as previewStateTesting,
8
+ applyPreviewServerEvent,
9
+ applyPreviewServerSnapshot,
10
+ beginPreviewSessionClose,
11
+ cancelPreviewSessionClose,
12
+ reconcilePreviewServerSessions,
13
+ resetPreviewStateForTests,
14
+} from "../../previewStateStore";
15
import { useRightPanelStore } from "../../rightPanelStore";
8
-import { followPreviewSessions, revealServerTabs } from "./agentOpenedPreviews";
16
+import {
17
+ followPreviewSessions,
18
+ revealServerTabs,
19
+ startAgentOpenedPreviews,
20
+} from "./agentOpenedPreviews";
21
22
vi.mock("../../state/entities", () => ({
23
readEnvironmentSupportsServerBrowser: () => true,
@@ -15,6 +27,7 @@ const ref = scopeThreadRef("env-1" as EnvironmentId, ThreadId.make("thread-1"));
27
const threadKey = scopedThreadKey(ref);
28
29
function setup() {
30
+ resetPreviewStateForTests();
31
usePreviewMiniPlayerStore.setState({ byThreadKey: {} });
32
useRightPanelStore.setState({ byThreadKey: {} });
33
}
@@ -106,3 +119,126 @@ describe("followPreviewSessions", () => {
119
expect(miniPlayerSource()).toBeUndefined();
120
});
121
});
122
+
123
+describe("startAgentOpenedPreviews", () => {
124
+ const serverEpoch = "server-a";
125
+ const serverTab = (overrides: Partial<PreviewSessionSnapshot> = {}): PreviewSessionSnapshot => ({
126
+ threadId: "thread-1",
127
+ tabId: "tab_a",
128
+ navStatus: { _tag: "Loading", url: "http://localhost:5173/", title: "" },
129
+ canGoBack: false,
130
+ canGoForward: false,
131
+ updatedAt: "2026-01-01T00:00:00.000Z",
132
+ runtime: "server",
133
+ reveal: true,
134
+ ...overrides,
135
+ });
136
+ const following = () => {
137
+ setup();
138
+ return { [Symbol.dispose]: startAgentOpenedPreviews() };
139
+ };
140
+ const navigated = (revision: number, snapshot: PreviewSessionSnapshot) =>
141
+ applyPreviewServerEvent(ref, {
142
+ type: "navigated",
143
+ threadId: "thread-1",
144
+ tabId: snapshot.tabId,
145
+ createdAt: snapshot.updatedAt,
146
+ snapshot,
147
+ serverEpoch,
148
+ revision,
149
+ });
150
+ const floatingTabId = () => {
151
+ const source = miniPlayerSource();
152
+ return source?.kind === "browser" ? source.tabId : null;
153
+ };
154
+ const browserTabs = (threadKeyToRead = threadKey) =>
155
+ useRightPanelStore
156
+ .getState()
157
+ .byThreadKey[threadKeyToRead]?.surfaces.filter((surface) => surface.kind === "preview")
158
+ .map((surface) => surface.id);
159
+
160
+ it("treats the first list as a baseline and floats tabs opened later", () => {
161
+ using _following = following();
162
+ reconcilePreviewServerSessions(ref, {
163
+ sessions: [serverTab({ tabId: "tab_restored" })],
164
+ serverEpoch,
165
+ revision: 1,
166
+ });
167
+ expect(floatingTabId()).toBeNull();
168
+ expect(browserTabs()).toEqual(["browser:tab_restored"]);
169
+
170
+ const opened = serverTab({ tabId: "tab_agent" });
171
+ applyPreviewServerEvent(ref, {
172
+ type: "opened",
173
+ threadId: "thread-1",
174
+ tabId: opened.tabId,
175
+ createdAt: opened.updatedAt,
176
+ snapshot: opened,
177
+ serverEpoch,
178
+ revision: 2,
179
+ });
180
+ expect(floatingTabId()).toBe("tab_agent");
181
+ });
182
+
183
+ it("reveals an existing tab only for a new reveal request", () => {
184
+ using _following = following();
185
+ const tab = serverTab({ revealRequest: { id: "r1", force: false } });
186
+ reconcilePreviewServerSessions(ref, { sessions: [tab], serverEpoch, revision: 1 });
187
+
188
+ navigated(2, { ...tab, updatedAt: "2026-01-01T00:00:01.000Z" });
189
+ expect(floatingTabId()).toBeNull();
190
+
191
+ navigated(3, {
192
+ ...tab,
193
+ revealRequest: { id: "r2", force: true },
194
+ updatedAt: "2026-01-01T00:00:02.000Z",
195
+ });
196
+ expect(useRightPanelStore.getState().byThreadKey[threadKey]?.activeSurfaceId).toBe(
197
+ "browser:tab_a",
198
+ );
199
+ });
200
+
201
+ it("never reveals tabs this client opened, desktop tabs, or a tab whose close failed", () => {
202
+ using _following = following();
203
+ const tab = serverTab({ tabId: "tab_closing" });
204
+ reconcilePreviewServerSessions(ref, { sessions: [tab], serverEpoch, revision: 1 });
205
+ applyPreviewServerSnapshot(ref, serverTab({ tabId: "tab_own", reveal: undefined }));
206
+ applyPreviewServerSnapshot(ref, { ...serverTab({ tabId: "tab_desktop" }), runtime: "desktop" });
207
+ beginPreviewSessionClose(ref, tab.tabId);
208
+ cancelPreviewSessionClose(ref, tab, tab.tabId);
209
+ expect(floatingTabId()).toBeNull();
210
+ });
211
+
212
+ it("follows background threads and closes the floating browser when its session ends", () => {
213
+ using _following = following();
214
+ const other = scopeThreadRef("env-1" as EnvironmentId, ThreadId.make("thread-2"));
215
+ reconcilePreviewServerSessions(other, {
216
+ sessions: [serverTab({ threadId: "thread-2", tabId: "tab_b" })],
217
+ serverEpoch,
218
+ revision: 1,
219
+ });
220
+ expect(browserTabs(scopedThreadKey(other))).toEqual(["browser:tab_b"]);
221
+
222
+ reconcilePreviewServerSessions(ref, { sessions: [], serverEpoch, revision: 1 });
223
+ const opened = serverTab();
224
+ applyPreviewServerEvent(ref, {
225
+ type: "opened",
226
+ threadId: "thread-1",
227
+ tabId: opened.tabId,
228
+ createdAt: opened.updatedAt,
229
+ snapshot: opened,
230
+ serverEpoch,
231
+ revision: 2,
232
+ });
233
+ expect(floatingTabId()).toBe("tab_a");
234
+ applyPreviewServerEvent(ref, {
235
+ type: "closed",
236
+ threadId: "thread-1",
237
+ tabId: opened.tabId,
238
+ createdAt: opened.updatedAt,
239
+ serverEpoch,
240
+ revision: 3,
241
+ });
242
+ expect(floatingTabId()).toBeNull();
243
+ });
244
+});
apps/web/src/components/preview/agentOpenedPreviews.ts
+55
-12
@@ -4,11 +4,12 @@ import type { PreviewSessionSnapshot, ScopedThreadRef } from "@t3tools/contracts
4
import { getClientSettings } from "../../hooks/useSettings";
5
import { browserMiniPlayerSource, usePreviewMiniPlayerStore } from "../../previewMiniPlayerStore";
6
import {
7
- onPreviewSessionsChanged,
8
- onServerTabsRevealed,
7
+ previewStateAtom,
8
+ previewThreadRefsAtom,
9
type ThreadPreviewState,
10
} from "../../previewStateStore";
11
import { useRightPanelStore } from "../../rightPanelStore";
12
+import { appAtomRegistry } from "../../rpc/atomRegistry";
13
import { readEnvironmentSupportsServerBrowser } from "../../state/entities";
14
15
/**
@@ -59,16 +60,58 @@ export function followPreviewSessions(threadRef: ScopedThreadRef, state: ThreadP
60
if (source?.kind === "browser" && !state.sessions[source.tabId]) miniPlayer.close(threadRef);
61
}
62
62
-let started = false;
63
+/**
64
+ * Server tabs that are new, or carry a new reveal request, since `previous`.
65
+ * Nothing is fresh until the first list has loaded: that list is the baseline,
66
+ * so a reload never reopens previews the user dismissed. A tab this client was
67
+ * closing comes back without a reveal if the close fails.
68
+ */
69
+function freshlyRevealedServerTabs(
70
+ previous: ThreadPreviewState,
71
+ next: ThreadPreviewState,
72
+): ReadonlyArray<PreviewSessionSnapshot> {
73
+ if (!previous.listLoaded || previous.sessions === next.sessions) return [];
74
+ return Object.values(next.sessions).filter((session) => {
75
+ if (session.runtime !== "server" || session.reveal !== true) return false;
76
+ if (previous.suppressedTabIds.has(session.tabId)) return false;
77
+ const before = previous.sessions[session.tabId];
78
+ const requested = session.revealRequest;
79
+ return requested ? before?.revealRequest?.id !== requested.id : before === undefined;
80
+ });
81
+}
82
+
83
+function followThread(threadKey: string, threadRef: ScopedThreadRef): () => void {
84
+ const atom = previewStateAtom(threadKey);
85
+ let previous = appAtomRegistry.get(atom);
86
+ return appAtomRegistry.subscribe(atom, (next) => {
87
+ const before = previous;
88
+ previous = next;
89
+ // Reveals run first so a revealed tab floats before it gains a panel tab.
90
+ const revealed = freshlyRevealedServerTabs(before, next);
91
+ if (revealed.length > 0) {
92
+ revealServerTabs(threadRef, revealed, {
93
+ autoShowFloatingPreview: getClientSettings().browserAutoShowFloatingPreview,
94
+ });
95
+ }
96
+ if (before.sessions !== next.sessions || before.listLoaded !== next.listLoaded) {
97
+ followPreviewSessions(threadRef, next);
98
+ }
99
+ });
100
+}
101
102
/** 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
- );
103
+export function startAgentOpenedPreviews(): () => void {
104
+ const followed = new Map<string, () => void>();
105
+ const followNewThreads = (refs: ReadonlyMap<string, ScopedThreadRef>) => {
106
+ for (const [threadKey, threadRef] of refs) {
107
+ if (!followed.has(threadKey)) followed.set(threadKey, followThread(threadKey, threadRef));
108
+ }
109
+ };
110
+ const stopIndex = appAtomRegistry.subscribe(previewThreadRefsAtom, followNewThreads, {
111
+ immediate: true,
112
+ });
113
+ return () => {
114
+ stopIndex();
115
+ for (const stop of followed.values()) stop();
116
+ };
117
}
apps/web/src/previewStateStore.test.ts
-74
@@ -19,7 +19,6 @@ import {
19
reconcilePreviewServerSessions,
20
resetPreviewStateForTests,
21
setActivePreviewTab,
22
- onServerTabsRevealed,
22
} from "./previewStateStore";
23
import { appAtomRegistry } from "./rpc/atomRegistry";
24
@@ -419,76 +418,3 @@ describe("previewStateStore (single-tab)", () => {
418
});
419
});
420
});
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
+23
-104
@@ -85,7 +85,15 @@ const activePreviewSessionsAtom = Atom.make((get) => {
85
return byThreadKey;
86
}).pipe(Atom.withLabel("preview:active-sessions"));
87
88
-const changedPreviewThreadKeys = new Set<string>();
88
+/**
89
+ * Every thread whose preview state has been written. Panel tabs and the mini
90
+ * player follow those threads' states from a store this one cannot import
91
+ * (rightPanelStore -> closedViewStore -> lib/utils -> composerDraftStore ->
92
+ * previewStateStore is a cycle), so they subscribe through this index.
93
+ */
94
+export const previewThreadRefsAtom = Atom.make<ReadonlyMap<string, ScopedThreadRef>>(
95
+ new Map(),
96
+).pipe(Atom.keepAlive, Atom.withLabel("preview:thread-refs"));
97
98
function syncActivePreviewThread(threadKey: string, state: ThreadPreviewState): void {
99
const active = Object.keys(state.sessions).length > 0;
@@ -98,111 +106,22 @@ function syncActivePreviewThread(threadKey: string, state: ThreadPreviewState):
106
});
107
}
108
101
-function writeThreadPreviewState(
109
+function updateThreadPreviewState(
110
ref: ScopedThreadRef,
111
update: (current: ThreadPreviewState) => ThreadPreviewState,
104
-): { readonly previous: ThreadPreviewState; readonly next: ThreadPreviewState } | null {
112
+): void {
113
const threadKey = scopedThreadKey(ref);
114
+ // Indexed before the write so a new thread's subscribers see this change.
115
+ appAtomRegistry.update(previewThreadRefsAtom, (refs) =>
116
+ refs.has(threadKey) ? refs : new Map(refs).set(threadKey, ref),
117
+ );
118
const atom = previewStateAtom(threadKey);
107
- let previousState = appAtomRegistry.get(atom);
108
- let nextState = previousState;
119
+ let nextState = appAtomRegistry.get(atom);
120
const changed = appAtomRegistry.modify(atom, (current) => {
110
- previousState = current;
121
nextState = update(current);
122
return [nextState !== current, nextState];
123
});
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);
124
+ if (changed) syncActivePreviewThread(threadKey, nextState);
125
}
126
127
const dedupeRecentUrls = (existing: string[], url: string): string[] => {
@@ -257,7 +176,7 @@ export function readThreadPreviewState(ref: ScopedThreadRef): ThreadPreviewState
176
}
177
178
export function applyPreviewServerEvent(ref: ScopedThreadRef, event: PreviewEvent): void {
260
- updateThreadPreviewStateFromServer(ref, (current) => {
179
+ updateThreadPreviewState(ref, (current) => {
180
if (current.serverEpoch !== null && event.serverEpoch !== current.serverEpoch) return current;
181
if (event.revision < current.serverRevision) return current;
182
const next = (() => {
@@ -328,7 +247,7 @@ export function applyPreviewServerSnapshot(
247
ref: ScopedThreadRef,
248
snapshot: PreviewSessionSnapshot | null,
249
): void {
331
- updateThreadPreviewStateFromServer(ref, (current) => {
250
+ updateThreadPreviewState(ref, (current) => {
251
if (!snapshot && current.snapshot === null) return current;
252
if (!snapshot) {
253
return {
@@ -360,7 +279,7 @@ export function updatePreviewServerSnapshot(
279
ref: ScopedThreadRef,
280
snapshot: PreviewSessionSnapshot,
281
): void {
363
- updateThreadPreviewStateFromServer(ref, (current) => {
282
+ updateThreadPreviewState(ref, (current) => {
283
if (current.suppressedTabIds.has(snapshot.tabId)) return current;
284
const existing = current.sessions[snapshot.tabId];
285
if (existing && existing.updatedAt > snapshot.updatedAt) return current;
@@ -383,7 +302,7 @@ export function reconcilePreviewServerSessions(
302
ref: ScopedThreadRef,
303
result: PreviewListResult,
304
): void {
386
- updateThreadPreviewStateFromServer(ref, (current) => {
305
+ updateThreadPreviewState(ref, (current) => {
306
const sameServer = current.serverEpoch === result.serverEpoch;
307
if (sameServer && result.revision < current.serverRevision) {
308
return current;
@@ -594,10 +513,10 @@ export function clearThreadPreviewState(ref: ScopedThreadRef): void {
513
}
514
515
export function resetPreviewStateForTests(): void {
597
- for (const threadKey of changedPreviewThreadKeys) {
516
+ for (const threadKey of appAtomRegistry.get(previewThreadRefsAtom).keys()) {
517
appAtomRegistry.set(previewStateAtom(threadKey), EMPTY_THREAD_PREVIEW_STATE);
518
}
600
- changedPreviewThreadKeys.clear();
519
+ appAtomRegistry.set(previewThreadRefsAtom, new Map());
520
appAtomRegistry.set(activePreviewThreadKeysAtom, { keys: new Set<string>() });
521
}
522