@devries-cameron20 / t3code Mirror · read-only / commits / f05c38f166
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 15:45 UTC

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