Skip to content

Commit 92c1d42

Browse files
committed
fix(web): hydrate existing primary browser sessions
1 parent a5bb9ee commit 92c1d42

8 files changed

Lines changed: 296 additions & 22 deletions

File tree

‎apps/server/src/preview/Manager.test.ts‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,27 @@ const layer = PreviewManager.layer.pipe(
4747
);
4848

4949
it.layer(layer)("PreviewManager", (it) => {
50+
it.effect("lists all environment tabs when the thread filter is omitted", () =>
51+
Effect.gen(function* () {
52+
const manager = yield* PreviewManager.PreviewManager;
53+
const firstThread = freshThreadId();
54+
const secondThread = freshThreadId();
55+
const first = yield* manager.open({ threadId: firstThread, runtime: "server" });
56+
const second = yield* manager.open({ threadId: secondThread, runtime: "server" });
57+
const all = yield* manager.list({});
58+
expect(all.sessions).toEqual(expect.arrayContaining([first, second]));
59+
const filtered = yield* manager.list({ threadId: firstThread });
60+
expect(filtered.sessions).toEqual([first]);
61+
expect(filtered.serverEpoch).toBe(all.serverEpoch);
62+
expect(filtered.revision).toBe(all.revision);
63+
yield* manager.close({ threadId: firstThread, tabId: first.tabId });
64+
const refreshed = yield* manager.list({});
65+
expect(refreshed.sessions.some((tab) => tab.tabId === first.tabId)).toBe(false);
66+
expect(refreshed.sessions).toContainEqual(second);
67+
expect(refreshed.revision).toBeGreaterThan(all.revision);
68+
}),
69+
);
70+
5071
it.effect("opens a session and emits opened with normalized URL", () =>
5172
Effect.gen(function* () {
5273
const threadId = freshThreadId();

‎apps/server/src/preview/Manager.ts‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -455,7 +455,10 @@ export const make = Effect.gen(function* PreviewManagerMake() {
455455
function* (input) {
456456
return yield* SynchronizedRef.get(stateRef).pipe(
457457
Effect.map((state): PreviewListResult => ({
458-
sessions: sessionsForThread(state, input.threadId)
458+
sessions: (input.threadId === undefined
459+
? Array.from(state.sessions.values())
460+
: sessionsForThread(state, input.threadId)
461+
)
459462
.map((s) => s.snapshot)
460463
.toSorted((a, b) => a.updatedAt.localeCompare(b.updatedAt)),
461464
serverEpoch,

‎apps/web/src/browser/HostedBrowserWebview.test.tsx‎

Lines changed: 134 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -6,8 +6,10 @@ import {
66
type ClientSettings,
77
type DesktopPreviewBridge,
88
type PreviewEvent,
9+
type PreviewListResult,
910
} from "@t3tools/contracts";
1011
import { AsyncResult, Atom } from "effect/reactivity";
12+
import { scopedThreadKey } from "@t3tools/client-runtime/environment";
1113
import { act } from "react";
1214
import { create, type ReactTestRenderer } from "react-test-renderer";
1315
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
@@ -46,7 +48,8 @@ vi.mock("~/state/primaryEnvironment", async () => {
4648
vi.mock("~/state/preview", () => ({
4749
previewEnvironment: {
4850
events: ({ environmentId }: { environmentId: string }) => previewEventsFor(environmentId),
49-
list: () => previewList,
51+
list: ({ input }: { input: { threadId?: string } }) =>
52+
input.threadId === undefined ? previewList : Atom.make(AsyncResult.initial()),
5053
},
5154
}));
5255

@@ -68,14 +71,15 @@ import * as desktopTabLifetime from "./desktopTabLifetime";
6871
import { HostedBrowserWebview } from "./HostedBrowserWebview";
6972
import { ElectronBrowserHost } from "./ElectronBrowserHost";
7073
import { previewRuntimeTabId } from "./previewRuntimeTabId";
71-
import { resetPreviewStateForTests } from "~/previewStateStore";
74+
import { previewStateAtom, resetPreviewStateForTests } from "~/previewStateStore";
75+
import { usePreviewSession } from "~/components/preview/usePreviewSession";
7276
import { AppAtomRegistryProvider, appAtomRegistry } from "~/rpc/atomRegistry";
7377

7478
const previewEvents = new Map<
7579
string,
7680
Atom.Writable<AsyncResult.AsyncResult<PreviewEvent>, AsyncResult.AsyncResult<PreviewEvent>>
7781
>();
78-
const previewList = Atom.make(AsyncResult.initial());
82+
const previewList = Atom.make<AsyncResult.AsyncResult<PreviewListResult>>(AsyncResult.initial());
7983
function previewEventsFor(environmentId: string) {
8084
let atom = previewEvents.get(environmentId);
8185
if (!atom) {
@@ -99,6 +103,7 @@ function deferred<A>() {
99103

100104
beforeEach(() => {
101105
resetPreviewStateForTests();
106+
appAtomRegistry.set(previewList, AsyncResult.initial());
102107
for (const atom of previewEvents.values()) appAtomRegistry.set(atom, AsyncResult.initial());
103108
__resetClientSettingsPersistenceForTests();
104109
useBrowserSurfaceStore.setState({ activityByTabId: {}, byTabId: {} });
@@ -132,6 +137,132 @@ beforeEach(() => {
132137
});
133138

134139
describe("Electron browser hosting outside the selected thread", () => {
140+
it("applies primary events once while a chat sync is mounted and still syncs remote threads", async () => {
141+
const local = {
142+
environmentId: EnvironmentId.make("desktop-primary"),
143+
threadId: ThreadId.make("selected-thread"),
144+
};
145+
const remote = { ...local, environmentId: EnvironmentId.make("remote-server") };
146+
function ChatSync() {
147+
usePreviewSession(local);
148+
usePreviewSession(remote);
149+
return null;
150+
}
151+
mocks.getClientSettings.mockResolvedValue(DEFAULT_CLIENT_SETTINGS);
152+
await act(async () => {
153+
await ensureClientSettingsHydrated();
154+
renderer = create(
155+
<AppAtomRegistryProvider>
156+
<ElectronBrowserHost />
157+
<ChatSync />
158+
</AppAtomRegistryProvider>,
159+
{
160+
createNodeMock: (element) =>
161+
element.type === "webview"
162+
? Object.assign(new EventTarget(), { getWebContentsId: () => 44 })
163+
: { scrollLeft: 0, scrollTop: 0, scrollTo: () => undefined },
164+
},
165+
);
166+
});
167+
const applied = vi.fn();
168+
const stop = appAtomRegistry.subscribe(previewStateAtom(scopedThreadKey(local)), (state) => {
169+
if (state.sessions["selected-tab"]) applied();
170+
});
171+
const opened: PreviewEvent = {
172+
type: "opened",
173+
threadId: local.threadId,
174+
tabId: "selected-tab",
175+
serverEpoch: "server",
176+
revision: 1,
177+
createdAt: "2026-10-07T00:00:00.000Z",
178+
snapshot: {
179+
threadId: local.threadId,
180+
tabId: "selected-tab",
181+
runtime: "server",
182+
navStatus: { _tag: "Idle" },
183+
canGoBack: false,
184+
canGoForward: false,
185+
updatedAt: "2026-10-07T00:00:00.000Z",
186+
},
187+
};
188+
try {
189+
await act(() => {
190+
appAtomRegistry.set(previewEventsFor(local.environmentId), AsyncResult.success(opened));
191+
appAtomRegistry.set(previewEventsFor(remote.environmentId), AsyncResult.success(opened));
192+
});
193+
expect(applied).toHaveBeenCalledOnce();
194+
expect(appAtomRegistry.get(previewStateAtom(scopedThreadKey(remote))).sessions).toEqual({
195+
"selected-tab": opened.snapshot,
196+
});
197+
expect(mocks.createTab).toHaveBeenCalledOnce();
198+
} finally {
199+
stop();
200+
}
201+
});
202+
203+
it("attaches existing tabs from the initial list and reconciles a reconnect without events", async () => {
204+
mocks.getClientSettings.mockResolvedValue(DEFAULT_CLIENT_SETTINGS);
205+
await act(async () => {
206+
await ensureClientSettingsHydrated();
207+
renderer = create(
208+
<AppAtomRegistryProvider>
209+
<ElectronBrowserHost />
210+
</AppAtomRegistryProvider>,
211+
{
212+
createNodeMock: (element) =>
213+
element.type === "webview"
214+
? Object.assign(new EventTarget(), { getWebContentsId: () => 43 })
215+
: { scrollLeft: 0, scrollTop: 0, scrollTo: () => undefined },
216+
},
217+
);
218+
});
219+
const threadRef = {
220+
environmentId: EnvironmentId.make("desktop-primary"),
221+
threadId: ThreadId.make("already-open"),
222+
};
223+
const initialList: PreviewListResult = {
224+
serverEpoch: "existing-server",
225+
revision: 1,
226+
sessions: [
227+
{
228+
threadId: threadRef.threadId,
229+
tabId: "existing-tab",
230+
runtime: "server",
231+
navStatus: { _tag: "Idle" },
232+
canGoBack: false,
233+
canGoForward: false,
234+
updatedAt: "2026-10-06T00:00:00.000Z",
235+
},
236+
],
237+
};
238+
await act(() => {
239+
appAtomRegistry.set(previewList, AsyncResult.success(initialList));
240+
});
241+
const runtimeTabId = previewRuntimeTabId(threadRef, initialList.serverEpoch, "existing-tab");
242+
expect(mocks.createTab).toHaveBeenCalledExactlyOnceWith(
243+
runtimeTabId,
244+
expect.objectContaining({
245+
serverTab: { threadId: threadRef.threadId, tabId: "existing-tab" },
246+
}),
247+
);
248+
expect(mocks.registerWebview).toHaveBeenCalledExactlyOnceWith(runtimeTabId, 43);
249+
250+
vi.useFakeTimers();
251+
await act(() => {
252+
appAtomRegistry.set(previewList, AsyncResult.success(initialList, { waiting: true }));
253+
});
254+
await vi.advanceTimersByTimeAsync(0);
255+
expect(mocks.closeTab).not.toHaveBeenCalled();
256+
await act(() => {
257+
appAtomRegistry.set(
258+
previewList,
259+
AsyncResult.success({ ...initialList, revision: 2, sessions: [] }),
260+
);
261+
});
262+
await vi.advanceTimersByTimeAsync(0);
263+
expect(mocks.closeTab).toHaveBeenCalledExactlyOnceWith(runtimeTabId);
264+
});
265+
135266
it("attaches a primary-server tab without a chat view and releases it when closed", async () => {
136267
mocks.getClientSettings.mockResolvedValue(DEFAULT_CLIENT_SETTINGS);
137268
await act(async () => {

‎apps/web/src/browser/useDesktopBrowserSessions.ts‎

Lines changed: 32 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -4,31 +4,48 @@ import { ThreadId, type EnvironmentId } from "@t3tools/contracts";
44
import { AsyncResult, Atom } from "effect/reactivity";
55

66
import { isElectron } from "~/env";
7-
import { applyPreviewServerEvent, resetPreviewServerEpoch } from "~/previewStateStore";
7+
import {
8+
applyPreviewServerEvent,
9+
reconcilePreviewEnvironmentSessions,
10+
resetPreviewServerEpoch,
11+
} from "~/previewStateStore";
812
import { previewEnvironment } from "~/state/preview";
913

1014
const inactiveAtom = Atom.make(() => undefined);
1115
const desktopBrowserSessionsAtom = Atom.family((environmentId: EnvironmentId) => {
1216
const eventsAtom = previewEnvironment.events({ environmentId, input: {} });
17+
const sessionsAtom = previewEnvironment.list({ environmentId, input: {} });
1318
return Atom.make((get) => {
19+
let disposed = false;
1420
let serverEpoch: string | null = null;
21+
get.addFinalizer(() => {
22+
disposed = true;
23+
});
24+
get.subscribe(eventsAtom, (result) => {
25+
if (!AsyncResult.isSuccess(result)) return;
26+
const event = result.value;
27+
if (serverEpoch !== event.serverEpoch) {
28+
resetPreviewServerEpoch(environmentId, event.serverEpoch);
29+
get.refresh(sessionsAtom);
30+
serverEpoch = event.serverEpoch;
31+
}
32+
applyPreviewServerEvent(scopeThreadRef(environmentId, ThreadId.make(event.threadId)), event);
33+
});
34+
// List queries re-run when the connection changes. Hydrate all existing tabs
35+
// as well as live events, including ones opened before the renderer attached.
36+
get.refresh(sessionsAtom);
1537
get.subscribe(
16-
eventsAtom,
38+
sessionsAtom,
1739
(result) => {
18-
if (!AsyncResult.isSuccess(result)) return;
19-
const event = result.value;
20-
if (serverEpoch !== event.serverEpoch) {
21-
for (const threadRef of resetPreviewServerEpoch(environmentId, event.serverEpoch)) {
22-
get.refresh(
23-
previewEnvironment.list({ environmentId, input: { threadId: threadRef.threadId } }),
24-
);
25-
}
26-
serverEpoch = event.serverEpoch;
40+
if (!AsyncResult.isSuccess(result) || result.waiting) return;
41+
serverEpoch = result.value.serverEpoch;
42+
if (!reconcilePreviewEnvironmentSessions(environmentId, result.value)) {
43+
// An event may have arrived after the first list was read. Fetch a
44+
// complete baseline before considering that thread's index ready.
45+
queueMicrotask(() => {
46+
if (!disposed) get.refresh(sessionsAtom);
47+
});
2748
}
28-
applyPreviewServerEvent(
29-
scopeThreadRef(environmentId, ThreadId.make(event.threadId)),
30-
event,
31-
);
3249
},
3350
{ immediate: true },
3451
);

‎apps/web/src/components/preview/usePreviewSession.ts‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,12 +6,14 @@ import type { ScopedThreadRef } from "@t3tools/contracts";
66
import * as Schema from "effect/Schema";
77
import { AsyncResult, Atom } from "effect/reactivity";
88

9+
import { isElectron } from "~/env";
910
import {
1011
applyPreviewServerEvent,
1112
readThreadPreviewState,
1213
reconcilePreviewServerSessions,
1314
} from "~/previewStateStore";
1415
import { previewEnvironment } from "~/state/preview";
16+
import { primaryEnvironmentIdAtom } from "~/state/primaryEnvironment";
1517

1618
class PreviewSessionThreadKeyParseError extends Schema.TaggedError<PreviewSessionThreadKeyParseError>()(
1719
"PreviewSessionThreadKeyParseError",
@@ -38,6 +40,8 @@ const previewSessionSyncAtom = Atom.family((threadKey: string) => {
3840
});
3941

4042
return Atom.make((get) => {
43+
const hostAppliesEvents =
44+
isElectron && threadRef.environmentId === get(primaryEnvironmentIdAtom);
4145
let disposed = false;
4246
let eventsVersion = 0;
4347

@@ -64,7 +68,8 @@ const previewSessionSyncAtom = Atom.family((threadKey: string) => {
6468
get.refresh(sessionsAtom);
6569
return;
6670
}
67-
applyPreviewServerEvent(threadRef, result.value);
71+
// The persistent host already applies this desktop's primary-server events.
72+
if (!hostAppliesEvents) applyPreviewServerEvent(threadRef, result.value);
6873
};
6974

7075
get.addFinalizer(() => {

‎apps/web/src/previewStateStore.test.ts‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@ import {
1616
cancelPreviewSessionClose,
1717
previewStateAtom,
1818
readThreadPreviewState,
19+
reconcilePreviewEnvironmentSessions,
1920
reconcilePreviewServerSessions,
2021
rememberPreviewUrl,
2122
resetPreviewStateForTests,
@@ -91,6 +92,68 @@ it("drops a restarted server's desktop pages without resetting another environme
9192
expect(readThreadPreviewState(remoteRef).snapshot?.tabId).toBe("remote-tab");
9293
});
9394

95+
it("hydrates unseen threads and reconciles missing tabs without overwriting newer events", () => {
96+
const remoteRef = scopeThreadRef("remote" as EnvironmentId, ref.threadId);
97+
reconcilePreviewServerSessions(remoteRef, {
98+
serverEpoch,
99+
revision: 1,
100+
sessions: [makeSnapshot({ tabId: "remote-tab" })],
101+
});
102+
reconcilePreviewEnvironmentSessions(environmentId, {
103+
serverEpoch,
104+
revision: 1,
105+
sessions: [makeSnapshot(), makeSnapshot({ threadId: otherRef.threadId, tabId: "background" })],
106+
});
107+
expect(readThreadPreviewState(otherRef).snapshot?.tabId).toBe("background");
108+
applyPreviewServerEventImpl(ref, {
109+
type: "opened",
110+
serverEpoch,
111+
revision: 3,
112+
threadId: ref.threadId,
113+
tabId: "newer-tab",
114+
snapshot: makeSnapshot({ tabId: "newer-tab" }),
115+
createdAt: "2026-10-06T00:00:00.000Z",
116+
});
117+
reconcilePreviewEnvironmentSessions(environmentId, {
118+
serverEpoch,
119+
revision: 2,
120+
sessions: [makeSnapshot()],
121+
});
122+
expect(readThreadPreviewState(ref).snapshot?.tabId).toBe("newer-tab");
123+
expect(readThreadPreviewState(otherRef).sessions).toEqual({});
124+
expect(readThreadPreviewState(remoteRef).snapshot?.tabId).toBe("remote-tab");
125+
});
126+
127+
it("requests another baseline when a live event overtakes the first environment list", () => {
128+
const live = makeSnapshot({ tabId: "live-tab" });
129+
applyPreviewServerEventImpl(ref, {
130+
type: "opened",
131+
serverEpoch,
132+
revision: 2,
133+
threadId: ref.threadId,
134+
tabId: live.tabId,
135+
snapshot: live,
136+
createdAt: live.updatedAt,
137+
});
138+
expect(
139+
reconcilePreviewEnvironmentSessions(environmentId, {
140+
serverEpoch,
141+
revision: 1,
142+
sessions: [makeSnapshot()],
143+
}),
144+
).toBe(false);
145+
expect(readThreadPreviewState(ref).sessions).toEqual({ "live-tab": live });
146+
expect(
147+
reconcilePreviewEnvironmentSessions(environmentId, {
148+
serverEpoch,
149+
revision: 2,
150+
sessions: [makeSnapshot(), live],
151+
}),
152+
).toBe(true);
153+
expect(Object.keys(readThreadPreviewState(ref).sessions)).toEqual(["tab_a", "live-tab"]);
154+
expect(readThreadPreviewState(ref).listLoaded).toBe(true);
155+
});
156+
94157
describe("previewStateStore (single-tab)", () => {
95158
it("keeps independent state atoms for each thread", () => {
96159
expect(previewStateAtom(scopedThreadKey(ref))).toBe(previewStateAtom(scopedThreadKey(ref)));

0 commit comments

Comments
 (0)