The best way to control Claude Code, Codex and more from any computer or phone
fix(web): browser viewport resizes work without an open preview panel (#25462)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Oct 26, 2026 at 07:21 UTC
f05c38f1667fcf36970affd09574a234c85e3bff
17 files changed
+555
-237
apps/web/src/AppRoot.tsx
-2
@@ -5,7 +5,6 @@ import { subscribeComposerDraftModelReconciliation } from "./composerDraftStore"
5
import { environmentThreadShells } from "./state/threads";
6
import { environmentShell } from "./state/shell";
7
8
-import { BrowserProfileReporter } from "./browser/BrowserProfileReporter";
8
import { ElectronBrowserHost } from "./browser/ElectronBrowserHost";
9
import { QuitHoldOverlay } from "./components/QuitHoldOverlay";
10
import { appAtomRegistry, AppAtomRegistryProvider } from "./rpc/atomRegistry";
@@ -27,7 +26,6 @@ export function AppRoot({ router }: { readonly router: AppRouter }) {
26
<AppAtomRegistryProvider>
27
<RouterProvider router={router} />
28
<ElectronBrowserHost />
30
- <BrowserProfileReporter />
29
<QuitHoldOverlay />
30
</AppAtomRegistryProvider>
31
);
apps/web/src/appInit.tsx
+4
@@ -5,6 +5,8 @@ import { createBrowserHistory, createHashHistory } from "@tanstack/react-router"
5
import { applyAppearanceContrast } from "./appearanceContrast";
6
import { applyAppearanceFontVariables } from "./appearanceFonts";
7
import { startElectronBrowserHost } from "./browser/ElectronBrowserHost";
8
+import { startBrowserProfileReporting } from "./browser/BrowserProfileReporter";
9
+import { startPreviewTitleRecording } from "./browserHistoryStore";
10
import { retainThreadOverlaysForThread } from "./components/chat/threadOverlayRetention";
11
import { startBackgroundThreadAnnouncements } from "./components/BackgroundThreadAnnouncer";
12
import { startSshPasswordPromptQueue } from "./components/desktop/SshPasswordPromptDialog";
@@ -164,6 +166,8 @@ export function startAppServices(): AppRouter {
166
startModelPreferencesMigration();
167
startAgentOpenedPreviews();
168
if (isElectron) startElectronBrowserHost();
169
+ startPreviewTitleRecording();
170
+ startBrowserProfileReporting();
171
startThreadOverlayRetention(router);
172
startMainAppLocationTracking(router);
173
startBackgroundThreadAnnouncements(appAtomRegistry, router);
apps/web/src/browser/BrowserProfileReporter.test.ts
new
+64
@@ -0,0 +1,64 @@
1
+import type { EnvironmentServerConfig } from "@t3tools/client-runtime/connection";
2
+import { EnvironmentId } from "@t3tools/contracts";
3
+import { describe, expect, it } from "vite-plus/test";
4
+
5
+import {
6
+ type ProfileReport,
7
+ type ReportedProfiles,
8
+ takeDueProfileReports,
9
+} from "./BrowserProfileReporter";
10
+
11
+const first = EnvironmentId.make("environment-1");
12
+const second = EnvironmentId.make("environment-2");
13
+const config = (label: string) => ({ label }) as unknown as EnvironmentServerConfig;
14
+const input = (recordingFrameRate: number) =>
15
+ ({ profiles: [], defaultProfileId: "default", recordingFrameRate }) as unknown as ProfileReport;
16
+
17
+describe("takeDueProfileReports", () => {
18
+ it("reports each environment once per config and input", () => {
19
+ const reported: ReportedProfiles = new Map();
20
+ const configA = config("a");
21
+ const configB = config("b");
22
+ const settings = input(10);
23
+ const targets = new Map([
24
+ [first, configA],
25
+ [second, configB],
26
+ ]);
27
+
28
+ expect(takeDueProfileReports(reported, targets, settings)).toEqual([first, second]);
29
+ expect(takeDueProfileReports(reported, new Map(targets), settings)).toEqual([]);
30
+
31
+ const restarted = config("a-restarted");
32
+ expect(
33
+ takeDueProfileReports(
34
+ reported,
35
+ new Map([
36
+ [first, restarted],
37
+ [second, configB],
38
+ ]),
39
+ settings,
40
+ ),
41
+ ).toEqual([first]);
42
+ });
43
+
44
+ it("reports every target again when the profile settings change", () => {
45
+ const reported: ReportedProfiles = new Map();
46
+ const targets = new Map([
47
+ [first, config("a")],
48
+ [second, config("b")],
49
+ ]);
50
+ takeDueProfileReports(reported, targets, input(10));
51
+
52
+ expect(takeDueProfileReports(reported, targets, input(30))).toEqual([first, second]);
53
+ });
54
+
55
+ it("reports an environment again once it becomes operable again", () => {
56
+ const reported: ReportedProfiles = new Map();
57
+ const configA = config("a");
58
+ const settings = input(10);
59
+ takeDueProfileReports(reported, new Map([[first, configA]]), settings);
60
+
61
+ expect(takeDueProfileReports(reported, new Map(), settings)).toEqual([]);
62
+ expect(takeDueProfileReports(reported, new Map([[first, configA]]), settings)).toEqual([first]);
63
+ });
64
+});
apps/web/src/browser/BrowserProfileReporter.ts
new
+106
@@ -0,0 +1,106 @@
1
+import type { EnvironmentServerConfig } from "@t3tools/client-runtime/connection";
2
+import { runAtomCommand } from "@t3tools/client-runtime/state/runtime";
3
+import { AuthPreviewOperateScope, type EnvironmentId } from "@t3tools/contracts";
4
+import type { ClientSettings } from "@t3tools/contracts/settings";
5
+import { Atom } from "effect/reactivity";
6
+
7
+import {
8
+ getClientSettings,
9
+ getClientSettingsHydratedSnapshot,
10
+ subscribeClientSettings,
11
+ subscribeClientSettingsHydration,
12
+} from "~/hooks/useSettings";
13
+import { appAtomRegistry } from "~/rpc/atomRegistry";
14
+import { environmentPresentations } from "~/state/presentation";
15
+import { previewEnvironment } from "~/state/preview";
16
+import { environmentSession, sessionHasScope } from "~/state/session";
17
+
18
+export interface ProfileReport {
19
+ readonly profiles: ClientSettings["browserProfiles"];
20
+ readonly defaultProfileId: ClientSettings["browserDefaultProfileId"];
21
+ readonly recordingFrameRate: ClientSettings["browserRecordingFrameRate"];
22
+}
23
+
24
+/** Server-browser environments this client may operate, with the config each currently runs. */
25
+const reportTargetsAtom = Atom.make((get) => {
26
+ const targets = new Map<EnvironmentId, EnvironmentServerConfig>();
27
+ for (const [environmentId, config] of get(environmentPresentations.serverConfigsAtom)) {
28
+ if (!config.environment.capabilities.serverBrowser) continue;
29
+ const session = get(environmentSession.sessionStateAtom(environmentId));
30
+ if (!sessionHasScope(session, AuthPreviewOperateScope)) continue;
31
+ targets.set(environmentId, config);
32
+ }
33
+ return targets;
34
+}).pipe(Atom.withLabel("browser-profile-report-targets"));
35
+
36
+/**
37
+ * Keeps every operable server browser on this client's profiles. An environment is reported
38
+ * again when its server config changes (a restarted server has forgotten them), when it becomes
39
+ * operable, and when the profile settings change.
40
+ */
41
+export function startBrowserProfileReporting(): () => void {
42
+ const reported: ReportedProfiles = new Map();
43
+ const report = () => {
44
+ if (!getClientSettingsHydratedSnapshot()) return;
45
+ const settings = getClientSettings();
46
+ const input: ProfileReport = {
47
+ profiles: settings.browserProfiles,
48
+ defaultProfileId: settings.browserDefaultProfileId,
49
+ recordingFrameRate: settings.browserRecordingFrameRate,
50
+ };
51
+ const targets = appAtomRegistry.get(reportTargetsAtom);
52
+ for (const environmentId of takeDueProfileReports(reported, targets, input)) {
53
+ void runAtomCommand(
54
+ appAtomRegistry,
55
+ previewEnvironment.reportProfiles,
56
+ { environmentId, input },
57
+ { reportFailure: false },
58
+ );
59
+ }
60
+ };
61
+ const unsubscribes = [
62
+ appAtomRegistry.subscribe(reportTargetsAtom, report),
63
+ subscribeClientSettings(report),
64
+ subscribeClientSettingsHydration(report),
65
+ ];
66
+ report();
67
+ return () => {
68
+ for (const unsubscribe of unsubscribes) unsubscribe();
69
+ };
70
+}
71
+
72
+export type ReportedProfiles = Map<
73
+ EnvironmentId,
74
+ { readonly config: EnvironmentServerConfig; readonly input: ProfileReport }
75
+>;
76
+
77
+/**
78
+ * Returns the targets that need `input` reported and records them in `reported`. An
79
+ * environment that dropped out of `targets` is forgotten, so it is reported again once it
80
+ * becomes operable.
81
+ */
82
+export function takeDueProfileReports(
83
+ reported: ReportedProfiles,
84
+ targets: ReadonlyMap<EnvironmentId, EnvironmentServerConfig>,
85
+ input: ProfileReport,
86
+): EnvironmentId[] {
87
+ for (const environmentId of reported.keys()) {
88
+ if (!targets.has(environmentId)) reported.delete(environmentId);
89
+ }
90
+ const due: EnvironmentId[] = [];
91
+ for (const [environmentId, config] of targets) {
92
+ const last = reported.get(environmentId);
93
+ if (last && last.config === config && sameReportInput(last.input, input)) continue;
94
+ reported.set(environmentId, { config, input });
95
+ due.push(environmentId);
96
+ }
97
+ return due;
98
+}
99
+
100
+function sameReportInput(left: ProfileReport, right: ProfileReport): boolean {
101
+ return (
102
+ left.profiles === right.profiles &&
103
+ left.defaultProfileId === right.defaultProfileId &&
104
+ left.recordingFrameRate === right.recordingFrameRate
105
+ );
106
+}
apps/web/src/browser/BrowserProfileReporter.tsx
deleted
-42
@@ -1,42 +0,0 @@
1
-import {
2
- AuthPreviewOperateScope,
3
- type BrowserProfile,
4
- type BrowserRecordingFrameRate,
5
-} from "@t3tools/contracts";
6
-import { useEffect } from "react";
7
-
8
-import { useClientSettings, useClientSettingsHydrated } from "~/hooks/useSettings";
9
-import { useServerConfigs } from "~/state/entities";
10
-import { useEnvironments } from "~/state/environments";
11
-import { previewEnvironment } from "~/state/preview";
12
-import { useEnvironmentsWithScope } from "~/state/session";
13
-import { useAtomCommand } from "~/state/use-atom-command";
14
-
15
-const selectProfiles = (settings: { readonly browserProfiles: ReadonlyArray<BrowserProfile> }) =>
16
- settings.browserProfiles;
17
-const selectDefaultProfileId = (settings: { readonly browserDefaultProfileId: string }) =>
18
- settings.browserDefaultProfileId;
19
-const selectRecordingFrameRate = (settings: {
20
- readonly browserRecordingFrameRate: BrowserRecordingFrameRate;
21
-}) => settings.browserRecordingFrameRate;
22
-
23
-export function BrowserProfileReporter() {
24
- const hydrated = useClientSettingsHydrated();
25
- const profiles = useClientSettings(selectProfiles);
26
- const defaultProfileId = useClientSettings(selectDefaultProfileId);
27
- const recordingFrameRate = useClientSettings(selectRecordingFrameRate);
28
- const { environments } = useEnvironments();
29
- const serverConfigs = useServerConfigs();
30
- const operable = useEnvironmentsWithScope(environments, AuthPreviewOperateScope);
31
- const report = useAtomCommand(previewEnvironment.reportProfiles, { reportFailure: false });
32
-
33
- useEffect(() => {
34
- if (!hydrated) return;
35
- for (const [environmentId, config] of serverConfigs) {
36
- if (!config.environment.capabilities.serverBrowser || !operable.has(environmentId)) continue;
37
- void report({ environmentId, input: { profiles, defaultProfileId, recordingFrameRate } });
38
- }
39
- }, [defaultProfileId, hydrated, operable, profiles, recordingFrameRate, report, serverConfigs]);
40
-
41
- return null;
42
-}
apps/web/src/browser/HostedBrowserWebview.tsx
+1
-1
@@ -236,7 +236,7 @@ export function HostedBrowserWebview(props: {
236
handleResizePointerDown,
237
layout: viewportLayout,
238
} = useBrowserViewportResize({
239
- tabId: runtimeTabId,
239
+ target: { threadRef, tabId, runtimeTabId },
240
viewport,
241
zoomFactor: layoutZoomFactor,
242
containerSize,
apps/web/src/browser/ServerBrowserSurface.tsx
+1
-8
@@ -49,7 +49,6 @@ export interface ServerBrowserHandle {
49
}
50
51
const RESIZE_THROTTLE_MS = 150;
52
-const ACCESS_RETRY_MS = 10_000;
52
// Reuse nearby probes when a slow link would return the tap's answer after it ends.
53
const PROBE_REUSE_PX = 24;
54
const PROBE_REUSE_MS = 10_000;
@@ -161,7 +160,6 @@ export function ServerBrowserSurface(props: {
160
pdfUrl = null,
161
ref,
162
} = props;
164
- const access = usePreviewStreamAccess(environmentId);
163
const canvasRef = useRef<HTMLCanvasElement | null>(null);
164
const inputRef = useRef<HTMLTextAreaElement | null>(null);
165
const keySentRef = useRef(false);
@@ -189,6 +187,7 @@ export function ServerBrowserSurface(props: {
187
};
188
const unauthorizedRef = useRef(0);
189
const [accessDenied, setAccessDenied] = useState(false);
190
+ const access = usePreviewStreamAccess(environmentId, { retry: visible && !accessDenied });
191
const [hostSetup, setHostSetup] = useState<PreviewStreamHostSetup | null>(null);
192
const pendingMoveRef = useRef<MouseInput | null>(null);
193
const pendingWheelRef = useRef<WheelInput | null>(null);
@@ -458,12 +457,6 @@ export function ServerBrowserSurface(props: {
457
visible,
458
]);
459
461
- useEffect(() => {
462
- if (!visible || accessDenied || access !== null) return;
463
- const timer = setInterval(() => refreshPreviewStreamAccess(environmentId), ACCESS_RETRY_MS);
464
- return () => clearInterval(timer);
465
- }, [access, accessDenied, environmentId, visible]);
466
-
460
useEffect(() => {
461
const canvas = canvasRef.current;
462
if (!canvas) return;
apps/web/src/browser/browserViewportActions.test.ts
+59
-17
@@ -1,9 +1,30 @@
1
-import { describe, expect, it } from "vite-plus/test";
1
+import { describe, expect, it, vi } from "vite-plus/test";
2
3
import {
4
- commitBrowserViewportChange,
5
- subscribeBrowserViewportChange,
6
-} from "./browserViewportActions";
4
+ EnvironmentId,
5
+ type PreviewViewportSetting,
6
+ ThreadId,
7
+ type PreviewSessionSnapshot,
8
+} from "@t3tools/contracts";
9
+
10
+const mocks = vi.hoisted(() => ({
11
+ resize: Symbol("preview-resize"),
12
+ runAtomCommand: vi.fn(),
13
+ updatePreviewServerSnapshot: vi.fn(),
14
+}));
15
+
16
+vi.mock("@t3tools/client-runtime/state/runtime", () => ({
17
+ runAtomCommand: mocks.runAtomCommand,
18
+ squashAtomCommandFailure: (result: { readonly error: unknown }) => result.error,
19
+}));
20
+vi.mock("~/rpc/atomRegistry", () => ({ appAtomRegistry: {} }));
21
+vi.mock("~/state/preview", () => ({ previewEnvironment: { resize: mocks.resize } }));
22
+vi.mock("~/previewStateStore", () => ({
23
+ updatePreviewServerSnapshot: mocks.updatePreviewServerSnapshot,
24
+}));
25
+vi.mock("~/components/ui/toast", () => ({ toastManager: { add: vi.fn() } }));
26
+
27
+import { commitBrowserViewportChange, queueBrowserViewportCommit } from "./browserViewportActions";
28
29
describe("browserViewportActions", () => {
30
it("commits viewport changes in order for each tab", async () => {
@@ -16,31 +37,52 @@ describe("browserViewportActions", () => {
37
markFirstStarted = resolve;
38
});
39
const calls: Array<number> = [];
19
- const unsubscribe = subscribeBrowserViewportChange("tab-serial", async (setting) => {
40
+ const resize = async (setting: PreviewViewportSetting) => {
41
if (setting._tag === "fill") return;
42
calls.push(setting.width);
43
if (setting.width === 800) {
44
markFirstStarted?.();
45
await firstPending;
46
}
26
- });
47
+ };
48
28
- const first = commitBrowserViewportChange("tab-serial", {
29
- _tag: "freeform",
30
- width: 800,
31
- height: 600,
32
- });
33
- const second = commitBrowserViewportChange("tab-serial", {
34
- _tag: "freeform",
35
- width: 900,
36
- height: 700,
37
- });
49
+ const first = queueBrowserViewportCommit("tab-serial", () =>
50
+ resize({ _tag: "freeform", width: 800, height: 600 }),
51
+ );
52
+ const second = queueBrowserViewportCommit("tab-serial", () =>
53
+ resize({ _tag: "freeform", width: 900, height: 700 }),
54
+ );
55
await firstStarted;
56
expect(calls).toEqual([800]);
57
58
releaseFirst?.();
59
await Promise.all([first, second]);
60
expect(calls).toEqual([800, 900]);
44
- unsubscribe();
61
+ });
62
+
63
+ it("resizes a tab that no preview panel is showing", async () => {
64
+ const threadRef = {
65
+ environmentId: EnvironmentId.make("env-1"),
66
+ threadId: ThreadId.make("thread-1"),
67
+ };
68
+ const snapshot = { tabId: "tab-1" } as PreviewSessionSnapshot;
69
+ mocks.runAtomCommand.mockResolvedValueOnce({ _tag: "Success", value: snapshot });
70
+ const viewport: PreviewViewportSetting = { _tag: "freeform", width: 390, height: 844 };
71
+
72
+ await commitBrowserViewportChange(
73
+ { threadRef, tabId: "tab-1", runtimeTabId: "runtime-tab-1" },
74
+ viewport,
75
+ );
76
+
77
+ expect(mocks.runAtomCommand).toHaveBeenCalledWith(
78
+ expect.anything(),
79
+ mocks.resize,
80
+ {
81
+ environmentId: threadRef.environmentId,
82
+ input: { threadId: threadRef.threadId, tabId: "tab-1", viewport },
83
+ },
84
+ expect.anything(),
85
+ );
86
+ expect(mocks.updatePreviewServerSnapshot).toHaveBeenCalledWith(threadRef, snapshot);
87
});
88
});
apps/web/src/browser/browserViewportActions.ts
+53
-21
@@ -1,6 +1,17 @@
1
-import type { PreviewViewportSetting } from "@t3tools/contracts";
1
+import { runAtomCommand, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
2
+import type { PreviewViewportSetting, ScopedThreadRef } from "@t3tools/contracts";
3
3
-type BrowserViewportHandler = (setting: PreviewViewportSetting) => Promise<void>;
4
+import { toastManager } from "~/components/ui/toast";
5
+import { updatePreviewServerSnapshot } from "~/previewStateStore";
6
+import { appAtomRegistry } from "~/rpc/atomRegistry";
7
+import { previewEnvironment } from "~/state/preview";
8
+
9
+/** One browser tab as both the server (thread + tab id) and this window's runtime know it. */
10
+export interface BrowserViewportTarget {
11
+ readonly threadRef: ScopedThreadRef;
12
+ readonly tabId: string;
13
+ readonly runtimeTabId: string;
14
+}
15
16
export const BROWSER_VIEWPORT_COMMIT_TIMEOUT_MS = 15_000;
17
@@ -12,7 +23,6 @@ class BrowserViewportCommitTimeoutError extends Error {
23
}
24
}
25
15
-const handlers = new Map<string, BrowserViewportHandler>();
26
const commitTails = new Map<string, Promise<void>>();
27
28
const queueBrowserViewportMutation = <A>(
@@ -59,27 +69,49 @@ const runHandlerWithTimeout = (tabId: string, operation: Promise<void>): Promise
69
});
70
};
71
62
-export function subscribeBrowserViewportChange(
63
- tabId: string,
64
- handler: BrowserViewportHandler,
65
-): () => void {
66
- handlers.set(tabId, handler);
67
- return () => {
68
- if (handlers.get(tabId) === handler) handlers.delete(tabId);
69
- };
72
+async function resizeBrowserViewport(
73
+ target: BrowserViewportTarget,
74
+ viewport: PreviewViewportSetting,
75
+): Promise<void> {
76
+ const result = await runAtomCommand(
77
+ appAtomRegistry,
78
+ previewEnvironment.resize,
79
+ {
80
+ environmentId: target.threadRef.environmentId,
81
+ input: { threadId: target.threadRef.threadId, tabId: target.tabId, viewport },
82
+ },
83
+ { label: "preview viewport resize" },
84
+ );
85
+ if (result._tag === "Failure") {
86
+ const error = squashAtomCommandFailure(result);
87
+ toastManager.add({
88
+ type: "error",
89
+ title: "Unable to resize browser viewport",
90
+ description: error instanceof Error ? error.message : "An error occurred.",
91
+ });
92
+ throw error;
93
+ }
94
+ updatePreviewServerSnapshot(target.threadRef, result.value);
95
+}
96
+
97
+/**
98
+ * Runs `operation` after every earlier commit for the runtime tab. The
99
+ * caller-facing timeout starts only once it reaches the front of the queue,
100
+ * while the queue itself waits for the real operation.
101
+ */
102
+export function queueBrowserViewportCommit(
103
+ runtimeTabId: string,
104
+ operation: () => Promise<void>,
105
+): Promise<void> {
106
+ const { started } = queueBrowserViewportMutation(runtimeTabId, operation);
107
+ return started.then(({ operation: running }) => runHandlerWithTimeout(runtimeTabId, running));
108
}
109
110
export function commitBrowserViewportChange(
73
- tabId: string,
111
+ target: BrowserViewportTarget,
112
setting: PreviewViewportSetting,
113
): Promise<void> {
76
- const { started } = queueBrowserViewportMutation(tabId, () => {
77
- const handler = handlers.get(tabId);
78
- return handler
79
- ? handler(setting)
80
- : Promise.reject(new Error(`No visible browser viewport handler for tab ${tabId}`));
81
- });
82
- // Queue until the handler finishes; start the caller timeout only when its turn begins.
83
- const result = started.then(({ operation }) => runHandlerWithTimeout(tabId, operation));
84
- return result;
114
+ return queueBrowserViewportCommit(target.runtimeTabId, () =>
115
+ resizeBrowserViewport(target, setting),
116
+ );
117
}
apps/web/src/browser/useBrowserViewportResize.ts
+6
-5
@@ -8,7 +8,7 @@ import {
8
} from "react";
9
10
import { useStableCallback } from "../hooks/useStableCallback";
11
-import { commitBrowserViewportChange } from "./browserViewportActions";
11
+import { type BrowserViewportTarget, commitBrowserViewportChange } from "./browserViewportActions";
12
import {
13
browserViewportSettingKey,
14
resizeBrowserViewportFromRail,
@@ -27,14 +27,15 @@ interface ViewportDrag extends PreviewViewportSize {
27
const KEYBOARD_RESIZE_COMMIT_DELAY_MS = 150;
28
29
export function useBrowserViewportResize(options: {
30
- readonly tabId: string;
30
+ readonly target: BrowserViewportTarget;
31
readonly viewport: PreviewViewportSetting;
32
readonly zoomFactor: number;
33
readonly containerSize: PreviewViewportSize;
34
readonly deviceToolbarVisible: boolean;
35
readonly aspectRatio: number | null;
36
}) {
37
- const { tabId, viewport, zoomFactor, containerSize, deviceToolbarVisible, aspectRatio } = options;
37
+ const { target, viewport, zoomFactor, containerSize, deviceToolbarVisible, aspectRatio } =
38
+ options;
39
const dragCleanupRef = useRef<(() => void) | null>(null);
40
const dragVersionRef = useRef(0);
41
const keyboardCommitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
@@ -91,7 +92,7 @@ export function useBrowserViewportResize(options: {
92
}
93
keyboardViewportRef.current = null;
94
setDragViewport(null);
94
- return commitBrowserViewportChange(tabId, next);
95
+ return commitBrowserViewportChange(target, next);
96
};
97
98
const clearDrag = () => setDragViewport(null);
@@ -100,7 +101,7 @@ export function useBrowserViewportResize(options: {
101
const clearIfCurrent = () => {
102
if (dragVersionRef.current === version) clearDrag();
103
};
103
- void commitBrowserViewportChange(tabId, next).then(clearIfCurrent, clearIfCurrent);
104
+ void commitBrowserViewportChange(target, next).then(clearIfCurrent, clearIfCurrent);
105
};
106
107
const handleResizeKeyDown = (
apps/web/src/browserHistoryStore.test.ts
+114
-22
@@ -1,6 +1,6 @@
1
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
2
3
-import { EnvironmentId, ThreadId } from "@t3tools/contracts";
3
+import { EnvironmentId, type PreviewSessionSnapshot, ThreadId } from "@t3tools/contracts";
4
5
const { readPreparedConnection } = vi.hoisted(() => ({
6
readPreparedConnection: vi.fn<() => { httpBaseUrl: string } | null>(() => null),
@@ -16,10 +16,11 @@ import {
16
normalizeHistoryUrl,
17
recordVisitForThread,
18
resetBrowserHistoryForTests,
19
- setTitleForThreadUrl,
19
+ startPreviewTitleRecording,
20
upsertHistoryEntry,
21
useBrowserHistoryStore,
22
} from "./browserHistoryStore";
23
+import { applyPreviewServerSnapshot, resetPreviewStateForTests } from "./previewStateStore";
24
25
function entry(overrides: Partial<BrowserHistoryEntry> = {}): BrowserHistoryEntry {
26
return { url: "http://localhost:3000/", lastVisitedAt: 1000, ...overrides };
@@ -108,24 +109,107 @@ const threadRef = {
109
threadId: ThreadId.make("thread-1"),
110
};
111
112
+let settledAt = 0;
113
+
114
+function settle(url: string, title: string, tabId = "tab_a", ref = threadRef): void {
115
+ settledAt += 1;
116
+ const snapshot: PreviewSessionSnapshot = {
117
+ threadId: ref.threadId,
118
+ tabId,
119
+ navStatus: { _tag: "Success", url, title },
120
+ canGoBack: false,
121
+ canGoForward: false,
122
+ updatedAt: new Date(settledAt).toISOString(),
123
+ };
124
+ applyPreviewServerSnapshot(ref, snapshot);
125
+}
126
+
127
+function resetStores(): () => void {
128
+ resetBrowserHistoryForTests();
129
+ resetPreviewStateForTests();
130
+ return startPreviewTitleRecording();
131
+}
132
+
133
describe("useBrowserHistoryStore", () => {
112
- beforeEach(() => {
113
- resetBrowserHistoryForTests();
114
- });
134
+ beforeEach(resetStores);
135
116
- it("sets titles update-only via the thread helper", () => {
136
+ it("titles only pages already in history when they settle", () => {
137
useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
118
- setTitleForThreadUrl(threadRef, "http://a.test/", "Should not create");
138
+ settle("http://a.test/", "Should not create");
139
expect(useBrowserHistoryStore.getState().byProjectKey).toEqual({});
140
recordVisitForThread(threadRef, "http://a.test/#/settings", 1);
121
- setTitleForThreadUrl(threadRef, "http://a.test/#/settings", "My App");
141
+ settle("http://a.test/#/settings", "My App");
142
expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.title).toBe("My App");
143
});
144
145
+ it("titles a visit recorded after its page already settled", () => {
146
+ useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
147
+ recordVisitForThread(threadRef, "http://other.test/", 1);
148
+ settle("http://a.test/", "My App");
149
+ recordVisitForThread(threadRef, "http://a.test/", 2);
150
+ expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]).toMatchObject({
151
+ url: "http://a.test/",
152
+ title: "My App",
153
+ });
154
+ });
155
+
156
+ it("keeps the newest title when another tab shows the same url", () => {
157
+ useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
158
+ recordVisitForThread(threadRef, "http://a.test/", 1);
159
+ settle("http://a.test/", "Old", "tab_a");
160
+ settle("http://a.test/", "Old", "tab_b");
161
+ settle("http://a.test/", "New", "tab_a");
162
+ expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.title).toBe("New");
163
+ });
164
+
165
+ it("keeps another thread's newer title when an unrelated tab settles", () => {
166
+ const otherThreadRef = { ...threadRef, threadId: ThreadId.make("thread-2") };
167
+ const store = useBrowserHistoryStore.getState();
168
+ store.registerThreadProject(threadRef, "proj-a");
169
+ store.registerThreadProject(otherThreadRef, "proj-a");
170
+ recordVisitForThread(threadRef, "http://a.test/", 1);
171
+ settle("http://a.test/", "Old", "tab_a", threadRef);
172
+ settle("http://a.test/", "New", "tab_a", otherThreadRef);
173
+ settle("http://b.test/", "Unrelated", "tab_b", threadRef);
174
+ expect(
175
+ useBrowserHistoryStore
176
+ .getState()
177
+ .byProjectKey["proj-a"]?.find((e) => e.url === "http://a.test/")?.title,
178
+ ).toBe("New");
179
+ });
180
+
181
+ it("keeps another thread's newer title when this thread records a different visit", () => {
182
+ const otherThreadRef = { ...threadRef, threadId: ThreadId.make("thread-2") };
183
+ const store = useBrowserHistoryStore.getState();
184
+ store.registerThreadProject(threadRef, "proj-a");
185
+ store.registerThreadProject(otherThreadRef, "proj-a");
186
+ recordVisitForThread(threadRef, "http://a.test/", 1);
187
+ settle("http://a.test/", "Old", "tab_a", threadRef);
188
+ settle("http://a.test/", "New", "tab_a", otherThreadRef);
189
+ recordVisitForThread(threadRef, "http://b.test/", 2);
190
+ expect(
191
+ useBrowserHistoryStore
192
+ .getState()
193
+ .byProjectKey["proj-a"]?.find((e) => e.url === "http://a.test/")?.title,
194
+ ).toBe("New");
195
+ });
196
+
197
+ it("keeps another thread's newer title when this thread revisits the same url", () => {
198
+ const otherThreadRef = { ...threadRef, threadId: ThreadId.make("thread-2") };
199
+ const store = useBrowserHistoryStore.getState();
200
+ store.registerThreadProject(threadRef, "proj-a");
201
+ store.registerThreadProject(otherThreadRef, "proj-a");
202
+ recordVisitForThread(threadRef, "http://a.test/", 1);
203
+ settle("http://a.test/", "Old", "tab_a", threadRef);
204
+ settle("http://a.test/", "New", "tab_a", otherThreadRef);
205
+ recordVisitForThread(threadRef, "http://a.test/", 2);
206
+ expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.title).toBe("New");
207
+ });
208
+
209
it("sets a title against a settled url that differs from the stored one only by a trailing slash", () => {
210
useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
211
recordVisitForThread(threadRef, "http://a.test/community", 1);
128
- setTitleForThreadUrl(threadRef, "http://a.test/community/", "Community");
212
+ settle("http://a.test/community/", "Community");
213
expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]).toMatchObject({
214
url: "http://a.test/community",
215
title: "Community",
@@ -133,7 +217,7 @@ describe("useBrowserHistoryStore", () => {
217
218
useBrowserHistoryStore.setState({ byProjectKey: {} });
219
recordVisitForThread(threadRef, "http://a.test/community/", 1);
136
- setTitleForThreadUrl(threadRef, "http://a.test/community", "Community");
220
+ settle("http://a.test/community", "Community");
221
expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]).toMatchObject({
222
url: "http://a.test/community/",
223
title: "Community",
@@ -143,7 +227,8 @@ describe("useBrowserHistoryStore", () => {
227
it("matches a requested localhost URL to the resolved environment host", () => {
228
useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
229
recordVisitForThread(threadRef, "http://localhost:5173/app", 1);
146
- setTitleForThreadUrl(threadRef, "http://192.168.64.2:5173/app", "Local App", "192.168.64.2");
230
+ readPreparedConnection.mockReturnValue({ httpBaseUrl: "http://192.168.64.2:3773" });
231
+ settle("http://192.168.64.2:5173/app", "Local App");
232
expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.title).toBe("Local App");
233
});
234
@@ -167,9 +252,7 @@ describe("useBrowserHistoryStore", () => {
252
});
253
254
describe("pendingVisitsByThreadKey", () => {
170
- beforeEach(() => {
171
- resetBrowserHistoryForTests();
172
- });
255
+ beforeEach(resetStores);
256
257
it("queues a visit recorded before registration and drains it in order on registration", () => {
258
recordVisitForThread(threadRef, "http://a.test/", 1);
@@ -201,21 +284,31 @@ describe("pendingVisitsByThreadKey", () => {
284
});
285
});
286
204
-describe("pendingTitlesByThreadKey", () => {
205
- beforeEach(() => {
206
- resetBrowserHistoryForTests();
207
- });
287
+describe("titles before registration", () => {
288
+ beforeEach(resetStores);
289
209
- it("buffers a title set before registration and applies it once the matching visit drains", () => {
290
+ it("applies a settled page's title once the matching visit drains", () => {
291
recordVisitForThread(threadRef, "http://a.test/", 1);
211
- setTitleForThreadUrl(threadRef, "http://a.test/", "My App");
292
+ settle("http://a.test/", "My App");
293
expect(useBrowserHistoryStore.getState().byProjectKey).toEqual({});
294
295
useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
296
297
const entries = useBrowserHistoryStore.getState().byProjectKey["proj-a"];
298
expect(entries?.[0]).toMatchObject({ url: "http://a.test/", title: "My App" });
218
- expect(useBrowserHistoryStore.getState().pendingTitlesByThreadKey).toEqual({});
299
+ });
300
+
301
+ it("keeps another thread's title when a queued visit to the same url drains", () => {
302
+ const otherThreadRef = { ...threadRef, threadId: ThreadId.make("thread-2") };
303
+ recordVisitForThread(threadRef, "http://a.test/", 1);
304
+ settle("http://a.test/", "Old", "tab_a", threadRef);
305
+ useBrowserHistoryStore.getState().registerThreadProject(otherThreadRef, "proj-a");
306
+ recordVisitForThread(otherThreadRef, "http://a.test/", 2);
307
+ settle("http://a.test/", "New", "tab_a", otherThreadRef);
308
+
309
+ useBrowserHistoryStore.getState().registerThreadProject(threadRef, "proj-a");
310
+
311
+ expect(useBrowserHistoryStore.getState().byProjectKey["proj-a"]?.[0]?.title).toBe("New");
312
});
313
});
314
@@ -238,6 +331,5 @@ describe("mergeBrowserHistoryState", () => {
331
expect(typeof merged.recordVisit).toBe("function");
332
expect(merged.projectKeyByThreadKey).toEqual({ good: "b" });
333
expect(merged.pendingVisitsByThreadKey).toEqual({});
241
- expect(merged.pendingTitlesByThreadKey).toEqual({});
334
});
335
});
apps/web/src/browserHistoryStore.ts
+85
-40
@@ -1,10 +1,17 @@
1
import { scopedThreadKey } from "@t3tools/client-runtime/environment";
2
-import type { ScopedThreadRef } from "@t3tools/contracts";
2
+import type { PreviewSessionSnapshot, ScopedThreadRef } from "@t3tools/contracts";
3
import { create } from "zustand";
4
import { createJSONStorage, persist } from "zustand/middleware";
5
import { useShallow } from "zustand/react/shallow";
6
7
import { normalizePreviewUrl } from "@t3tools/shared/preview";
8
+import {
9
+ previewStateAtom,
10
+ previewThreadRefsAtom,
11
+ readThreadPreviewState,
12
+ type ThreadPreviewState,
13
+} from "~/previewStateStore";
14
+import { appAtomRegistry } from "~/rpc/atomRegistry";
15
import { readPreparedConnection } from "~/state/session";
16
17
import { isLocalLoopbackHost, normalizeHostname } from "./browser/browserTargetResolver";
@@ -144,13 +151,11 @@ const PENDING_MAX_PER_THREAD = 10;
151
const PENDING_MAX_THREADS = 20;
152
153
type PendingVisit = { url: string; at: number; environmentHostname: string | null };
147
-type PendingTitle = { url: string; title: string; environmentHostname: string | null | undefined };
154
155
interface BrowserHistoryStoreState {
156
byProjectKey: Record<string, BrowserHistoryEntry[]>;
157
projectKeyByThreadKey: Record<string, string>;
158
pendingVisitsByThreadKey: Record<string, PendingVisit[]>;
153
- pendingTitlesByThreadKey: Record<string, PendingTitle[]>;
159
recordVisit: (
160
projectKey: string,
161
url: string,
@@ -189,7 +194,6 @@ export const useBrowserHistoryStore = create<BrowserHistoryStoreState>()(
194
byProjectKey: {},
195
projectKeyByThreadKey: {},
196
pendingVisitsByThreadKey: {},
192
- pendingTitlesByThreadKey: {},
197
recordVisit: (projectKey, url, at, options) => {
198
const normalized = normalizeHistoryUrl(url);
199
if (!normalized) return;
@@ -245,35 +249,22 @@ export const useBrowserHistoryStore = create<BrowserHistoryStoreState>()(
249
const threadKey = scopedThreadKey(ref);
250
const state = get();
251
const pendingVisits = state.pendingVisitsByThreadKey[threadKey];
248
- const pendingTitles = state.pendingTitlesByThreadKey[threadKey];
249
- if (
250
- state.projectKeyByThreadKey[threadKey] === projectKey &&
251
- !pendingVisits &&
252
- !pendingTitles
253
- ) {
254
- return;
255
- }
252
+ if (state.projectKeyByThreadKey[threadKey] === projectKey && !pendingVisits) return;
253
const nextPendingVisits = { ...state.pendingVisitsByThreadKey };
257
- const nextPendingTitles = { ...state.pendingTitlesByThreadKey };
254
delete nextPendingVisits[threadKey];
259
- delete nextPendingTitles[threadKey];
255
set({
256
projectKeyByThreadKey: { ...state.projectKeyByThreadKey, [threadKey]: projectKey },
257
pendingVisitsByThreadKey: nextPendingVisits,
263
- pendingTitlesByThreadKey: nextPendingTitles,
258
});
259
for (const visit of pendingVisits ?? [])
260
get().recordVisit(projectKey, visit.url, visit.at, {
261
insertOrdered: true,
262
environmentHostname: visit.environmentHostname,
263
});
270
- for (const pendingTitle of pendingTitles ?? [])
271
- get().setTitleForUrl(
272
- projectKey,
273
- pendingTitle.url,
274
- pendingTitle.title,
275
- pendingTitle.environmentHostname,
276
- );
264
+ if (pendingVisits)
265
+ recordPreviewTitles(ref, readThreadPreviewState(ref), {
266
+ urls: pendingVisits.map((visit) => visit.url),
267
+ });
268
},
269
}),
270
{
@@ -302,7 +293,6 @@ export function mergeBrowserHistoryState(
293
...migrated,
294
projectKeyByThreadKey: migratePersistedThreadProjectKeys(persistedState, migrated.byProjectKey),
295
pendingVisitsByThreadKey: {},
305
- pendingTitlesByThreadKey: {},
296
};
297
}
298
@@ -341,28 +331,84 @@ export function recordVisitForThread(ref: ScopedThreadRef, url: string, at?: num
331
return;
332
}
333
state.recordVisit(projectKey, url, visitAt, { environmentHostname });
334
+ // A page can settle before the address bar records its visit.
335
+ recordPreviewTitles(ref, readThreadPreviewState(ref), { urls: [url] });
336
}
337
346
-export function setTitleForThreadUrl(
338
+/**
339
+ * Titles only update entries already in history, so they apply on settle and on
340
+ * visit. History is shared across a project's threads and settled sessions stay
341
+ * retained, so a visit only fills untitled entries: replaying this thread's
342
+ * older settle would clobber a newer title. Settles apply what just changed.
343
+ */
344
+function recordPreviewTitles(
345
ref: ScopedThreadRef,
348
- url: string,
349
- title: string,
350
- environmentHostname?: string | null,
346
+ preview: ThreadPreviewState,
347
+ only:
348
+ | { readonly urls: ReadonlyArray<string> }
349
+ | { readonly changedSince: ThreadPreviewState["sessions"] },
350
): void {
352
- const threadKey = scopedThreadKey(ref);
351
const state = useBrowserHistoryStore.getState();
354
- const projectKey = state.projectKeyByThreadKey[threadKey];
355
- if (!projectKey) {
356
- useBrowserHistoryStore.setState({
357
- pendingTitlesByThreadKey: addPendingByThread(state.pendingTitlesByThreadKey, threadKey, {
358
- url,
359
- title,
360
- environmentHostname,
361
- }),
362
- });
363
- return;
352
+ const projectKey = state.projectKeyByThreadKey[scopedThreadKey(ref)];
353
+ if (!projectKey || !state.byProjectKey[projectKey]?.length) return;
354
+ const connection = readPreparedConnection(ref.environmentId);
355
+ const environmentHostname = connection ? new URL(connection.httpBaseUrl).hostname : null;
356
+ const titleKey = (url: string) => {
357
+ const normalized = normalizeHistoryUrl(url);
358
+ return normalized ? titleLookupKey(normalized, environmentHostname) : null;
359
+ };
360
+ const titled = new Set(
361
+ "urls" in only
362
+ ? state.byProjectKey[projectKey]?.flatMap((entry) =>
363
+ entry.title ? [titleLookupKey(entry.url, environmentHostname)] : [],
364
+ )
365
+ : [],
366
+ );
367
+ const visitKeys =
368
+ "urls" in only
369
+ ? new Set(only.urls.map(titleKey).filter((key) => key !== null && !titled.has(key)))
370
+ : null;
371
+ const include = (session: PreviewSessionSnapshot, url: string) =>
372
+ "changedSince" in only
373
+ ? only.changedSince[session.tabId] !== session
374
+ : (visitKeys?.has(titleKey(url)) ?? false);
375
+ // Tabs can share a URL; applying oldest first lets the newest settle win.
376
+ const sessions = Object.values(preview.sessions).toSorted((a, b) =>
377
+ a.updatedAt.localeCompare(b.updatedAt),
378
+ );
379
+ for (const session of sessions) {
380
+ const status = session.navStatus;
381
+ if (status._tag !== "Success" || !status.title || !include(session, status.url)) continue;
382
+ state.setTitleForUrl(projectKey, status.url, status.title, environmentHostname);
383
}
365
- state.setTitleForUrl(projectKey, url, title, environmentHostname);
384
+}
385
+
386
+/** Records settled page titles for every thread with previews, for the life of the page. */
387
+export function startPreviewTitleRecording(): () => void {
388
+ const followed = new Map<string, () => void>();
389
+ const followNewThreads = (refs: ReadonlyMap<string, ScopedThreadRef>) => {
390
+ for (const [threadKey, threadRef] of refs) {
391
+ if (followed.has(threadKey)) continue;
392
+ const atom = previewStateAtom(threadKey);
393
+ let previousSessions = appAtomRegistry.get(atom).sessions;
394
+ followed.set(
395
+ threadKey,
396
+ appAtomRegistry.subscribe(atom, (next) => {
397
+ if (next.sessions === previousSessions) return;
398
+ const changedSince = previousSessions;
399
+ previousSessions = next.sessions;
400
+ recordPreviewTitles(threadRef, next, { changedSince });
401
+ }),
402
+ );
403
+ }
404
+ };
405
+ const stopIndex = appAtomRegistry.subscribe(previewThreadRefsAtom, followNewThreads, {
406
+ immediate: true,
407
+ });
408
+ return () => {
409
+ stopIndex();
410
+ for (const stop of followed.values()) stop();
411
+ };
412
}
413
414
export function removeUrlForThread(ref: ScopedThreadRef, url: string): void {
@@ -392,7 +438,6 @@ export function resetBrowserHistoryForTests(): void {
438
byProjectKey: {},
439
projectKeyByThreadKey: {},
440
pendingVisitsByThreadKey: {},
395
- pendingTitlesByThreadKey: {},
441
});
442
useBrowserHistoryStore.persist.clearStorage();
443
}
apps/web/src/components/preview/PreviewChromeRow.tsx
+4
-12
@@ -11,8 +11,7 @@ import {
11
type FormEvent,
12
type KeyboardEvent,
13
type ReactNode,
14
- useEffect,
15
- useRef,
14
+ type RefObject,
15
useState,
16
} from "react";
17
@@ -28,7 +27,8 @@ interface Props {
27
canGoForward: boolean;
28
refreshDisabled: boolean;
29
inputDisabled?: boolean | undefined;
31
- focusUrlNonce?: number | undefined;
30
+ /** Owned by the caller so its shortcut handler can focus the address bar directly. */
31
+ urlInputRef: RefObject<HTMLInputElement | null>;
32
onBack: () => void;
33
onForward: () => void;
34
onRefresh: () => void;
@@ -57,7 +57,7 @@ export function PreviewChromeRow({
57
canGoForward,
58
refreshDisabled,
59
inputDisabled,
60
- focusUrlNonce,
60
+ urlInputRef: inputRef,
61
onBack,
62
onForward,
63
onRefresh,
@@ -76,17 +76,9 @@ export function PreviewChromeRow({
76
trailingActions,
77
leadingActions,
78
}: Props) {
79
- const inputRef = useRef<HTMLInputElement | null>(null);
79
const [draft, setDraft] = useState(url);
80
const [inputFocused, setInputFocused] = useState(false);
81
83
- useEffect(() => {
84
- if (focusUrlNonce == null) return;
85
- const node = inputRef.current;
86
- if (!node) return;
87
- node.focus();
88
- }, [focusUrlNonce]);
89
-
82
const submit = (event?: FormEvent | KeyboardEvent) => {
83
event?.preventDefault();
84
const next = draft.trim();
apps/web/src/components/preview/PreviewView.browser.test.tsx
+15
@@ -160,6 +160,7 @@ import { useComposerDraftStore } from "~/composerDraftStore";
160
import { useBrowserPointerStore } from "~/browser/browserPointerStore";
161
import { previewRuntimeTabId } from "~/browser/previewRuntimeTabId";
162
import { usePreviewMiniPlayerStore } from "~/previewMiniPlayerStore";
163
+import { dispatchPreviewAction } from "./previewActionBus";
164
import { PreviewView } from "./PreviewView";
165
166
const TEST_THREAD_REF = {
@@ -271,4 +272,18 @@ describe("PreviewView", () => {
272
expect(mocks.addPreviewAnnotation).toHaveBeenCalledWith(TEST_THREAD_REF, sent);
273
expect(mocks.addImage).not.toHaveBeenCalled();
274
});
275
+
276
+ it("focuses the address bar each time the focus-url shortcut fires", async () => {
277
+ setup();
278
+ await using _screen = await render(view());
279
+ const address = page.getByRole("textbox");
280
+
281
+ act(() => dispatchPreviewAction("focus-url"));
282
+ await expect.element(address).toHaveFocus();
283
+
284
+ (address.element() as HTMLInputElement).blur();
285
+ await expect.element(address).not.toHaveFocus();
286
+ act(() => dispatchPreviewAction("focus-url"));
287
+ await expect.element(address).toHaveFocus();
288
+ });
289
});
apps/web/src/components/preview/PreviewView.tsx
+16
-63
@@ -1,4 +1,4 @@
1
-import { scopeThreadRef, scopedThreadKey } from "@t3tools/client-runtime/environment";
1
+import { scopedThreadKey } from "@t3tools/client-runtime/environment";
2
import { settlePromise } from "@t3tools/client-runtime/state/runtime";
3
import { previewStreamDownloadUrl } from "@t3tools/client-runtime/preview/server-browser-stream";
4
import {
@@ -10,7 +10,6 @@ import {
10
DEFAULT_BROWSER_PROFILE_ID,
11
FILL_PREVIEW_VIEWPORT,
12
type PreviewAnnotationPayload,
13
- type PreviewViewportSetting,
13
type ScopedThreadRef,
14
DEFAULT_PREVIEW_ZOOM_FACTOR,
15
PREVIEW_ZOOM_LEVELS,
@@ -28,7 +27,6 @@ import {
27
BROWSER_HISTORY_MAX_ENTRIES_PER_PROJECT,
28
recordVisitForThread,
29
removeUrlForThread,
31
- setTitleForThreadUrl,
30
useThreadRecentHistory,
31
} from "~/browserHistoryStore";
32
import { type ComposerImageAttachment, useComposerDraftStore } from "~/composerDraftStore";
@@ -66,10 +64,7 @@ import { showPreviewPopup } from "./showPreviewPopup";
64
import { PreviewChromeRow } from "./PreviewChromeRow";
65
import { PreviewEmptyState } from "./PreviewEmptyState";
66
import { PreviewMoreMenu, type PreviewMoreMenuActions } from "./PreviewMoreMenu";
69
-import {
70
- commitBrowserViewportChange,
71
- subscribeBrowserViewportChange,
72
-} from "~/browser/browserViewportActions";
67
+import { commitBrowserViewportChange } from "~/browser/browserViewportActions";
68
import { browserResponsiveViewportForToggle, useBrowserDefaults } from "~/browser/browserDefaults";
69
import { BrowserDeviceToolbar } from "~/browser/BrowserDeviceToolbar";
70
import { BROWSER_DEVICE_TOOLBAR_HEIGHT } from "~/browser/browserViewportLayout";
@@ -150,7 +145,7 @@ export function PreviewView({
145
visible,
146
onSendAnnotation,
147
}: Props) {
153
- const [focusUrlNonce, setFocusUrlNonce] = useState<number | undefined>(undefined);
148
+ const urlInputRef = useRef<HTMLInputElement | null>(null);
149
const [pickActive, setPickActive] = useState(false);
150
const canSendAnnotation =
151
useEnvironmentScope(threadRef.environmentId, AuthOrchestrationOperateScope) &&
@@ -169,15 +164,11 @@ export function PreviewView({
164
const addPreviewAnnotation = useComposerDraftStore((store) => store.addPreviewAnnotation);
165
const addImage = useComposerDraftStore((store) => store.addImage);
166
const environmentHttpBaseUrl = useEnvironmentHttpBaseUrl(threadRef.environmentId);
172
- const environmentHostname = environmentHttpBaseUrl
173
- ? new URL(environmentHttpBaseUrl).hostname
174
- : null;
167
const open = useAtomCommand(previewEnvironment.open);
168
const closePreview = useAtomCommand(previewEnvironment.close, "preview close");
169
const environmentLabel = useEnvironment(threadRef.environmentId)?.label ?? "the environment";
170
const primaryEnvironmentId = usePrimaryEnvironmentId();
171
const serverBrowser = useEnvironmentSupportsServerBrowser(threadRef.environmentId);
180
- const resize = useAtomCommand(previewEnvironment.resize, "preview viewport resize");
172
const adjust = useAtomCommand(previewEnvironment.adjust, "preview appearance or zoom");
173
174
usePreviewSession(threadRef);
@@ -205,10 +196,10 @@ export function PreviewView({
196
const serverOwnsRendering = snapshot?.runtime === "server";
197
const serverSurfaceRef = useRef<ServerBrowserHandle | null>(null);
198
const [serverAspectRatioLocked, setServerAspectRatioLocked] = useState(false);
208
- const serverBodyRef = useRef<HTMLDivElement | null>(null);
199
const [serverToolbarWidth, setServerToolbarWidth] = useState(0);
200
const serverToolbarShown =
201
snapshot?.runtime === "server" && (snapshot.viewport ?? FILL_PREVIEW_VIEWPORT)._tag !== "fill";
202
+ const serverBodyRef = useRef<HTMLDivElement | null>(null);
203
useEffect(() => {
204
const element = serverBodyRef.current;
205
if (!element || !serverToolbarShown) return;
@@ -241,20 +232,6 @@ export function PreviewView({
232
runtimeTabId ? (state.byTabId[runtimeTabId]?.rect ?? null) : null,
233
);
234
244
- const navUrl = navStatus._tag === "Success" ? navStatus.url : null;
245
- const navTitle = navStatus._tag === "Success" ? navStatus.title : null;
246
- const latestHistoryUrl = recentHistoryEntries[0]?.url;
247
- const { environmentId: threadEnvironmentId, threadId } = threadRef;
248
- useEffect(() => {
249
- if (!navUrl || !navTitle || !latestHistoryUrl) return;
250
- setTitleForThreadUrl(
251
- scopeThreadRef(threadEnvironmentId, threadId),
252
- navUrl,
253
- navTitle,
254
- environmentHostname,
255
- );
256
- }, [environmentHostname, latestHistoryUrl, navTitle, navUrl, threadEnvironmentId, threadId]);
257
-
235
const navigateToResolvedUrl = async (resolvedUrl: string) => {
236
if (isServerTab && serverSurfaceRef.current) {
237
if (serverInputDisabled) return false;
@@ -355,37 +332,16 @@ export function PreviewView({
332
else if (previewBridge && runtimeTabId) void previewBridge.resetZoom(runtimeTabId);
333
};
334
358
- const handleViewportChange = async (nextViewport: PreviewViewportSetting) => {
359
- if (!tabId) return;
360
- const result = await resize({
361
- environmentId: threadRef.environmentId,
362
- input: {
363
- threadId: threadRef.threadId,
364
- tabId,
365
- viewport: nextViewport,
366
- },
367
- });
368
- if (result._tag === "Failure") {
369
- const error = squashAtomCommandFailure(result);
370
- toastManager.add({
371
- type: "error",
372
- title: "Unable to resize browser viewport",
373
- description: error instanceof Error ? error.message : "An error occurred.",
374
- });
375
- throw error;
376
- }
377
- updatePreviewServerSnapshot(threadRef, result.value);
378
- };
379
-
335
const handleToggleDeviceToolbar = () => {
381
- if (!runtimeTabId) return;
336
+ if (!runtimeTabId || !tabId) return;
337
+ const target = { threadRef, tabId, runtimeTabId };
338
if (viewport._tag !== "fill") {
383
- void commitBrowserViewportChange(runtimeTabId, FILL_PREVIEW_VIEWPORT).catch(() => undefined);
339
+ void commitBrowserViewportChange(target, FILL_PREVIEW_VIEWPORT).catch(() => undefined);
340
return;
341
}
342
343
void commitBrowserViewportChange(
388
- runtimeTabId,
344
+ target,
345
browserResponsiveViewportForToggle({
346
defaults: browserDefaults,
347
panelRect,
@@ -394,14 +350,6 @@ export function PreviewView({
350
).catch(() => undefined);
351
};
352
397
- const onViewportChange = useEffectEvent(handleViewportChange);
398
- useEffect(() => {
399
- if (!runtimeTabId) return;
400
- return subscribeBrowserViewportChange(runtimeTabId, (nextViewport) =>
401
- onViewportChange(nextViewport),
402
- );
403
- }, [runtimeTabId]);
404
-
353
const handleBack = () => {
354
if (isServerTab) serverSurfaceRef.current?.history(-1);
355
else if (previewBridge && runtimeTabId) void previewBridge.goBack(runtimeTabId);
@@ -875,7 +823,7 @@ export function PreviewView({
823
handleRefresh();
824
return;
825
case "focus-url":
878
- setFocusUrlNonce((value) => (value ?? 0) + 1);
826
+ urlInputRef.current?.focus();
827
return;
828
case "zoom-in":
829
handleZoomIn();
@@ -908,7 +856,7 @@ export function PreviewView({
856
canGoForward={canGoForward && !serverInputDisabled}
857
refreshDisabled={refreshDisabled || serverInputDisabled}
858
inputDisabled={serverInputDisabled}
911
- focusUrlNonce={focusUrlNonce}
859
+ urlInputRef={urlInputRef}
860
onBack={handleBack}
861
onForward={handleForward}
862
onRefresh={handleRefresh}
@@ -978,7 +926,12 @@ export function PreviewView({
926
width={serverToolbarWidth}
927
aspectRatio={serverAspectRatioLocked ? viewport.width / viewport.height : null}
928
onAspectRatioChange={(ratio) => setServerAspectRatioLocked(ratio !== null)}
981
- onChange={(setting) => commitBrowserViewportChange(runtimeTabId, setting)}
929
+ onChange={(setting) =>
930
+ commitBrowserViewportChange(
931
+ { threadRef, tabId: snapshot.tabId, runtimeTabId },
932
+ setting,
933
+ )
934
+ }
935
/>
936
</div>
937
) : null}
apps/web/src/hooks/useSettings.ts
+2
-2
@@ -113,7 +113,7 @@ export function subscribeClientSettings(listener: () => void): () => void {
113
};
114
}
115
116
-function getClientSettingsHydratedSnapshot(): boolean {
116
+export function getClientSettingsHydratedSnapshot(): boolean {
117
return clientSettingsHydrationStatus === "ready";
118
}
119
@@ -121,7 +121,7 @@ function getClientSettingsHydrationStatusSnapshot(): ClientSettingsHydrationStat
121
return clientSettingsHydrationStatus;
122
}
123
124
-function subscribeClientSettingsHydration(listener: () => void): () => void {
124
+export function subscribeClientSettingsHydration(listener: () => void): () => void {
125
clientSettingsHydrationListeners.add(listener);
126
void hydrateClientSettings().catch(() => undefined);
127
return () => {
apps/web/src/state/previewStream.ts
+25
-2
@@ -13,6 +13,8 @@ import { connectionAtomRuntime } from "../connection/runtime";
13
import { appAtomRegistry } from "../rpc/atomRegistry";
14
import { environmentSession } from "./session";
15
16
+const ACCESS_RETRY_INTERVAL_MS = 10_000;
17
+
18
const previewStreamAccessAtom = Atom.family((environmentId: EnvironmentId) =>
19
connectionAtomRuntime
20
.atom((get) => {
@@ -25,8 +27,29 @@ const previewStreamAccessAtom = Atom.family((environmentId: EnvironmentId) =>
27
.pipe(Atom.setIdleTTL(60_000), Atom.withLabel(`preview-stream-access:${environmentId}`)),
28
);
29
28
-export function usePreviewStreamAccess(environmentId: EnvironmentId): DeviceHubAccess | null {
29
- const result = useAtomValue(previewStreamAccessAtom(environmentId));
30
+// Only a surface the user is looking at retries a failed lookup; one-shot readers such as
31
+// picture-in-picture see the failure at once.
32
+const retryingPreviewStreamAccessAtom = Atom.family((environmentId: EnvironmentId) =>
33
+ Atom.make((get) => {
34
+ const access = previewStreamAccessAtom(environmentId);
35
+ const result = get(access);
36
+ if (AsyncResult.isFailure(result)) {
37
+ const timer = setTimeout(() => get.refresh(access), ACCESS_RETRY_INTERVAL_MS);
38
+ get.addFinalizer(() => clearTimeout(timer));
39
+ }
40
+ return result;
41
+ }),
42
+);
43
+
44
+export function usePreviewStreamAccess(
45
+ environmentId: EnvironmentId,
46
+ options?: { readonly retry: boolean },
47
+): DeviceHubAccess | null {
48
+ const result = useAtomValue(
49
+ options?.retry
50
+ ? retryingPreviewStreamAccessAtom(environmentId)
51
+ : previewStreamAccessAtom(environmentId),
52
+ );
53
return AsyncResult.isSuccess(result) ? result.value : null;
54
}
55