@devries-cameron20 / t3code-1 / commits / b16728af84
Fork 0

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