@devries-cameron20 / t3code-1 / commits / 35dcdd601e
Fork 0

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

fix(server): phone taps, typing and scrolling reach desktop browser tabs again (#19456)

Co-authored-by: PR Batch Tester <agent@local.test> Co-authored-by: Max Nylander <jztmanyl@gmail.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

shivam committed Oct 30, 2026 at 21:44 UTC 35dcdd601e11d821e0df5fd3435b350e92d15bf6
2 files changed +293 -25
apps/server/src/preview/ServerBrowser.test.ts
+204 -7
@@ -24,6 +24,7 @@ import * as Path from "effect/Path";
24 import * as PubSub from "effect/PubSub";
25 import * as Queue from "effect/Queue";
26 import * as Stream from "effect/Stream";
27 +import * as TestClock from "effect/testing/TestClock";
28 import type { BrowserContext, Page } from "playwright-core";
29 import { beforeEach, expect, vi } from "vite-plus/test";
30
@@ -56,6 +57,7 @@ vi.mock("./ServerBrowserContexts.ts", () => ({
57 }
58 async connectDesktopPage(endpoint: string) {
59 const context = makeContext();
60 + context.page.viewportSize.mockReturnValue(null);
61 desktopConnections.push({ endpoint, context });
62 return { browser: { close: async () => {} }, page: context.page as unknown as Page };
63 }
@@ -83,11 +85,16 @@ const PNG_HEADER = (() => {
85 return header.toString("base64");
86 })();
87
86 -function makeSession(frame?: ReturnType<typeof makeFrame>) {
88 +function makeSession(
89 + frame: ReturnType<typeof makeFrame> | undefined,
90 + viewport: { width: number; height: number },
91 +) {
92 const events = new NodeEvents.EventEmitter();
93 return {
89 - on: vi.fn((name: string, listener: () => void) => events.on(name, listener)),
90 - emit: (name: string) => events.emit(name),
94 + on: vi.fn((name: string, callback: (...args: unknown[]) => void) => events.on(name, callback)),
95 + emit: (name: string, ...args: unknown[]) => events.emit(name, ...args),
96 + emitAsync: (name: string, ...args: unknown[]) =>
97 + Promise.all(events.listeners(name).map((listener) => listener(...args))),
98 detach: vi.fn(async () => {}),
99 send: vi.fn(async (method: string, input?: unknown): Promise<Record<string, unknown>> => {
100 if (method === "Page.getNavigationHistory") return { currentIndex: 0, entries: [{}] };
@@ -101,7 +108,12 @@ function makeSession(frame?: ReturnType<typeof makeFrame>) {
108 if (method === "Page.getFrameTree") return { frameTree: { frame: { id: "main" } } };
109 if (method === "Page.createIsolatedWorld") {
110 return {
104 - executionContextId: (input as { worldName?: string }).worldName === "t3-preview" ? 1 : 7,
111 + executionContextId:
112 + (input as { worldName?: string }).worldName === "t3-preview-viewport"
113 + ? 9
114 + : (input as { worldName?: string }).worldName === "t3-preview"
115 + ? 1
116 + : 7,
117 };
118 }
119 if (method === "Runtime.evaluate" && (input as { contextId?: number }).contextId === 1) {
@@ -118,6 +130,8 @@ function makeSession(frame?: ReturnType<typeof makeFrame>) {
130 else pageCopy = "";
131 return { result: { value } };
132 }
133 + if (method === "Runtime.evaluate" && (input as { contextId?: number }).contextId === 9)
134 + return desktopSizeAnswer?.() ?? { result: { value: { ...viewport } } };
135 return { result: { value: "evaluated" } };
136 }),
137 };
@@ -129,7 +143,8 @@ function makeContext(onClose?: (context: BrowserContext) => void) {
143 const setChooserFiles = vi.fn(async (_files: unknown) => {});
144 const sessions: ReturnType<typeof makeSession>[] = [];
145 let url = "about:blank";
132 - let viewport = { width: 1280, height: 800 };
146 + let viewport: ReturnType<Page["viewportSize"]> = { width: 1280, height: 800 };
147 + const cssViewport = { width: 1920, height: 1080 };
148 let closed = false;
149 let contextClosed = false;
150 const page = {
@@ -159,7 +174,7 @@ function makeContext(onClose?: (context: BrowserContext) => void) {
174 frames: () => [page],
175 url: () => url,
176 title: vi.fn(async () => "test page"),
162 - viewportSize: () => viewport,
177 + viewportSize: vi.fn(() => viewport),
178 setViewportSize: vi.fn(async (size: typeof viewport) => {
179 viewport = size;
180 }),
@@ -197,11 +212,13 @@ function makeContext(onClose?: (context: BrowserContext) => void) {
212 const context = {
213 page,
214 sessions,
215 + cssViewport,
216 newPage: async () => page as unknown as Page,
217 grantPermissions: vi.fn(async () => {}),
218 newCDPSession: async (target: unknown) => {
219 const session = makeSession(
220 target === page ? undefined : (target as ReturnType<typeof makeFrame>),
221 + cssViewport,
222 );
223 sessions.push(session);
224 return session;
@@ -268,7 +285,11 @@ let focusedFrame: ReturnType<typeof makeFrame> | null = null;
285 let contextFailure: Error | null = null;
286 let initialNavigation: (() => Promise<void>) | null = null;
287 let desktopRendersNext = false;
288 +/** Replaces the answer to the desktop page's size reads. */
289 +let desktopSizeAnswer: (() => Promise<Record<string, unknown>>) | null = null;
290 const desktopDetaches = new NodeEvents.EventEmitter();
291 +let desktopDetachReady = Promise.withResolvers<void>();
292 +let desktopReleased = Promise.withResolvers<void>();
293 const desktopTabs = new Set<string>();
294 const desktopRenders = (tabId: string) => {
295 if (desktopRendersNext) {
@@ -317,6 +338,7 @@ const dependencies = Layer.mergeAll(
338 const onDetach = (key: { threadId: string; tabId: string }) =>
339 Queue.offerUnsafe(queue, key);
340 desktopDetaches.on("detach", onDetach);
341 + desktopDetachReady.resolve();
342 return onDetach;
343 }),
344 (onDetach) => Effect.sync(() => desktopDetaches.off("detach", onDetach)),
@@ -336,7 +358,10 @@ const dependencies = Layer.mergeAll(
358 isAttached: (key) => Effect.sync(() => desktopRenders(key.tabId)),
359 endpoint: (key) =>
360 Effect.acquireRelease(Effect.succeed(`ws://desktop/${key.tabId}`), () =>
339 - Effect.sync(() => releasedDesktopTabs.push(key.tabId)),
361 + Effect.sync(() => {
362 + releasedDesktopTabs.push(key.tabId);
363 + desktopReleased.resolve();
364 + }),
365 ),
366 pointer: () => Effect.void,
367 turn: (threadId, active) => Effect.sync(() => desktopTurns.emit("turn", threadId, active)),
@@ -367,6 +392,33 @@ const viewerInput = (tabId: string, canOperate: boolean) => ({
392 maxHeight: 800,
393 quality: 70,
394 });
395 +/** Fills a viewer's output with frames; resolves once every one of them is acknowledged. */
396 +const stallViewer = (viewer: ServerBrowser.ServerBrowserViewer) => {
397 + const output = viewer.output as unknown as Queue.Queue<ServerBrowser.ServerBrowserViewerOutput>;
398 + const acked = Promise.withResolvers<void>();
399 + let unacked = 0;
400 + const ack = Effect.sync(() => {
401 + if (--unacked === 0) acked.resolve();
402 + });
403 + while (Queue.offerUnsafe(output, { _tag: "frame", data: Buffer.alloc(0), ack })) unacked++;
404 + return Effect.promise(() => acked.promise);
405 +};
406 +const viewportSizes = (items: ReadonlyArray<ServerBrowser.ServerBrowserViewerOutput>) =>
407 + items.flatMap((item) => (item._tag === "viewport" ? [`${item.width}x${item.height}`] : []));
408 +const openDesktopViewer = Effect.gen(function* () {
409 + const browser = yield* ServerBrowser.ServerBrowser;
410 + const manager = yield* Manager.PreviewManager;
411 + desktopRendersNext = true;
412 + const { tabId } = yield* manager.open({ threadId: scope.thread.threadId, runtime: "server" });
413 + const viewer = yield* browser.attachViewer(viewerInput(tabId, true));
414 + const context = desktopConnections[0]!.context;
415 + const cdp = context.sessions[0]!;
416 + const resize = (width: number, height: number) => {
417 + Object.assign(context.cssViewport, { width, height });
418 + return Effect.promise(() => cdp.emitAsync("Page.frameResized"));
419 + };
420 + return { tabId, viewer, context, cdp, resize };
421 +});
422
423 beforeEach(() => {
424 contexts.length = 0;
@@ -380,6 +432,9 @@ beforeEach(() => {
432 focusedFrame = null;
433 desktopTabs.clear();
434 desktopRendersNext = false;
435 + desktopSizeAnswer = null;
436 + desktopDetachReady = Promise.withResolvers<void>();
437 + desktopReleased = Promise.withResolvers<void>();
438 releasedDesktopTabs.length = 0;
439 desktopConnections.length = 0;
440 });
@@ -1144,6 +1199,148 @@ it.live("only the current controller can answer a file picker", () =>
1199 ).pipe(Effect.provide(layer)),
1200 );
1201
1202 +it.effect(
1203 + "desktop viewers get the page's CSS size and keep the last one a read cannot measure",
1204 + () =>
1205 + Effect.scoped(
1206 + Effect.gen(function* () {
1207 + // Each page size read waits here for its answer.
1208 + const reads = yield* Queue.unbounded<PromiseWithResolvers<Record<string, unknown>>>();
1209 + const deferReads = () => {
1210 + desktopSizeAnswer = () => {
1211 + const read = Promise.withResolvers<Record<string, unknown>>();
1212 + Queue.offerUnsafe(reads, read);
1213 + return read.promise;
1214 + };
1215 + };
1216 + deferReads();
1217 + const { viewer, cdp, context } = yield* openDesktopViewer;
1218 + const answer = (width: number, height: number) => ({
1219 + result: { value: { width, height } },
1220 + });
1221 + const resized = () => cdp.emitAsync("Page.frameResized");
1222 + // The read on attach never answers and gives up with no size to send.
1223 + const blocked = yield* Queue.take(reads);
1224 + yield* TestClock.adjust("1 second");
1225 + // The next page load measures again.
1226 + desktopSizeAnswer = null;
1227 + yield* Effect.promise(() => cdp.emitAsync("Page.loadEventFired"));
1228 + expect(viewportSizes(yield* Queue.takeAll(viewer.output))).toEqual(["1920x1080"]);
1229 + // While a dialog is open nothing reads. The host closing it clears it, and since
1230 + // closing resizes nothing, the close itself remeasures.
1231 + deferReads();
1232 + context.page.emit("dialog", {
1233 + type: () => "alert",
1234 + message: () => "",
1235 + defaultValue: () => "",
1236 + });
1237 + yield* Effect.promise(resized);
1238 + expect(yield* Queue.size(reads)).toBe(0);
1239 + desktopSizeAnswer = null;
1240 + yield* Effect.promise(() => cdp.emitAsync("Page.javascriptDialogClosed"));
1241 + expect(viewportSizes(yield* Queue.takeAll(viewer.output))).toEqual([
1242 + "1920x1080",
1243 + "1920x1080",
1244 + ]);
1245 + // The late answer, a read a navigation breaks and a hidden webview keep the last size.
1246 + blocked.resolve(answer(100, 100));
1247 + deferReads();
1248 + const navigated = resized();
1249 + (yield* Queue.take(reads)).reject(new Error("Cannot find context with specified id"));
1250 + yield* Effect.promise(() => navigated);
1251 + const hidden = resized();
1252 + (yield* Queue.take(reads)).resolve(answer(0, 0));
1253 + yield* Effect.promise(() => hidden);
1254 + expect(viewportSizes(yield* Queue.takeAll(viewer.output))).toEqual([
1255 + "1920x1080",
1256 + "1920x1080",
1257 + ]);
1258 + // Resizes during a read share one more read, so the newest size arrives last.
1259 + const first = resized();
1260 + const firstRead = yield* Queue.take(reads);
1261 + const burst = Promise.all([resized(), resized()]);
1262 + firstRead.resolve(answer(800, 500));
1263 + (yield* Queue.take(reads)).resolve(answer(1000, 600));
1264 + expect(yield* Queue.size(reads)).toBe(0);
1265 + yield* Effect.promise(() => Promise.all([first, burst]));
1266 + expect(viewportSizes(yield* Queue.takeAll(viewer.output))).toEqual([
1267 + "800x500",
1268 + "1000x600",
1269 + "1000x600",
1270 + ]);
1271 + }),
1272 + ).pipe(Effect.provide(layer)),
1273 +);
1274 +
1275 +it.effect("a stalled desktop viewer still gets its size, control and reconnect", () =>
1276 + Effect.scoped(
1277 + Effect.gen(function* () {
1278 + const { tabId, viewer, context, resize } = yield* openDesktopViewer;
1279 + const output =
1280 + viewer.output as unknown as Queue.Queue<ServerBrowser.ServerBrowserViewerOutput>;
1281 + // Ready once the sizes measured on attach and on a first resize both arrived.
1282 + yield* resize(1920, 1080);
1283 + expect(viewportSizes(yield* Queue.takeAll(viewer.output))).toEqual([
1284 + "1920x1080",
1285 + "1920x1080",
1286 + ]);
1287 + yield* Effect.promise(() => desktopDetachReady.promise);
1288 + yield* viewer.input({ type: "takeControl" });
1289 + context.page.emit("filechooser", {
1290 + isMultiple: () => false,
1291 + element: () => ({ getAttribute: async () => ".csv" }),
1292 + setFiles: vi.fn(async () => {}),
1293 + });
1294 + let chooser = yield* Queue.take(viewer.output);
1295 + while (chooser._tag !== "fileChooser") chooser = yield* Queue.take(viewer.output);
1296 + yield* Queue.clear(viewer.output);
1297 + // A resize compacts a full backlog but keeps control, the open picker and
1298 + // one-time notifications in order.
1299 + yield* viewer.input({ type: "takeControl" });
1300 + const notifications: Array<ServerBrowser.ServerBrowserViewerOutput> = [
1301 + { _tag: "fileChooserClosed", id: "chooser-0" },
1302 + { _tag: "popup", tabId: "popup-1" },
1303 + { _tag: "download", id: "download-1", fileName: "report.csv", sizeBytes: 3 },
1304 + { _tag: "clipboard", text: "copied" },
1305 + ];
1306 + for (const item of notifications) Queue.offerUnsafe(output, item);
1307 + let acked = stallViewer(viewer);
1308 + yield* resize(1000, 600);
1309 + expect(yield* Queue.takeAll(viewer.output)).toEqual([
1310 + chooser,
1311 + ...notifications,
1312 + expect.objectContaining({ _tag: "control", controller: "you" }),
1313 + { _tag: "viewport", width: 1000, height: 600 },
1314 + ]);
1315 + yield* acked;
1316 + // A control change keeps only the newest size.
1317 + yield* resize(900, 500);
1318 + yield* resize(1200, 700);
1319 + acked = stallViewer(viewer);
1320 + yield* viewer.input({ type: "releaseControl" });
1321 + expect(yield* Queue.takeAll(viewer.output)).toEqual([
1322 + expect.objectContaining({ _tag: "control", controller: "unclaimed" }),
1323 + { _tag: "viewport", width: 1200, height: 700 },
1324 + ]);
1325 + yield* acked;
1326 + // Notifications that no longer fit go oldest first, never the size.
1327 + let copies = 0;
1328 + while (Queue.offerUnsafe(output, { _tag: "clipboard", text: `copy ${copies}` })) copies++;
1329 + yield* resize(1000, 600);
1330 + const compacted = yield* Queue.takeAll(viewer.output);
1331 + expect(compacted.at(0)).toEqual({ _tag: "clipboard", text: "copy 1" });
1332 + expect(compacted.at(-1)).toEqual({ _tag: "viewport", width: 1000, height: 600 });
1333 + // The desktop takes the page back; a resize after it cannot bury the reconnect.
1334 + acked = stallViewer(viewer);
1335 + desktopDetaches.emit("detach", { threadId: scope.thread.threadId, tabId });
1336 + yield* Effect.promise(() => desktopReleased.promise);
1337 + yield* resize(1000, 600);
1338 + expect(yield* Queue.takeAll(viewer.output)).toEqual([{ _tag: "reconnect" }]);
1339 + yield* acked;
1340 + }),
1341 + ).pipe(Effect.provide(layer)),
1342 +);
1343 +
1344 it.live("agents read a human's tab with no arguments and act on it only while nobody drives", () =>
1345 Effect.scoped(
1346 Effect.gen(function* () {
apps/server/src/preview/ServerBrowser.ts
+89 -18
@@ -102,6 +102,8 @@ const RECORDING_SCREENCAST = { format: "jpeg", quality: 90, everyNthFrame: 1 } a
102 const decodeViewportSetting = Schema.decodeUnknownSync(PreviewViewportSettingSchema);
103 const AGENT_CURSOR_MOVE_MS = 160;
104 const AGENT_CURSOR_CLICK_LEAD_MS = 40;
105 +/** A dialog blocks page script, so a desktop size read gives up after this. */
106 +const DESKTOP_VIEWPORT_READ_TIMEOUT = "1 second";
107
108 const sleepUntil = (deadline: number) =>
109 new Promise<void>((resolve) => setTimeout(resolve, Math.max(0, deadline - Date.now())));
@@ -309,6 +311,11 @@ interface ServerTab {
311 setting: PreviewViewportSetting;
312 colorScheme: PreviewAppearancePreference;
313 zoomFactor: number;
314 + /** Last usable CSS size measured on the desktop. */
315 + desktopViewport: { readonly width: number; readonly height: number } | null;
316 + desktopViewportRead: Promise<ServerTab["desktopViewport"]>;
317 + /** A read queued behind `desktopViewportRead`, shared by every caller that waits for it. */
318 + desktopViewportNext: Promise<ServerTab["desktopViewport"]> | null;
319 loading: boolean;
320 closing: boolean;
321 recording: Recording | null;
@@ -605,9 +612,48 @@ const make = Effect.gen(function* () {
612 );
613 };
614
608 - const layoutSize = (tab: ServerTab) => {
615 + // Desktop pages have no Playwright viewport; an isolated world keeps page script
616 + // from overriding the CSS size, and failed reads preserve the last usable size.
617 + const readDesktopViewport = async (tab: ServerTab) => {
618 + const readSize = async () => {
619 + const { frameTree } = await tab.cdp.send("Page.getFrameTree");
620 + const { executionContextId } = await tab.cdp.send("Page.createIsolatedWorld", {
621 + frameId: frameTree.frame.id,
622 + worldName: "t3-preview-viewport",
623 + });
624 + const { result } = await tab.cdp.send("Runtime.evaluate", {
625 + expression: "({ width: innerWidth, height: innerHeight })",
626 + contextId: executionContextId,
627 + returnByValue: true,
628 + });
629 + return asRecord(result.value);
630 + };
631 + const size = await runPromise(
632 + // A navigation can destroy the isolated world mid-read.
633 + Effect.promise(() => readSize().catch(() => null)).pipe(
634 + Effect.timeoutOption(DESKTOP_VIEWPORT_READ_TIMEOUT),
635 + Effect.map(Option.getOrNull),
636 + ),
637 + );
638 + const width = size?.width;
639 + const height = size?.height;
640 + if (typeof width === "number" && width > 0 && typeof height === "number" && height > 0)
641 + tab.desktopViewport = { width, height };
642 + return tab.desktopViewport;
643 + };
644 +
645 + // Reads run one at a time, and callers that arrive during a read share the next one.
646 + const measureDesktopViewport = (tab: ServerTab) =>
647 + (tab.desktopViewportNext ??= tab.desktopViewportRead.then(() => {
648 + tab.desktopViewportNext = null;
649 + return (tab.desktopViewportRead = readDesktopViewport(tab));
650 + }));
651 +
652 + const layoutSize = async (tab: ServerTab) => {
653 + // A dialog blocks page script; its close measures again.
654 + if (tab.desktop) return tab.dialog ? tab.desktopViewport : measureDesktopViewport(tab);
655 const size = tab.page.viewportSize();
610 - if (!size || tab.desktop) return size;
656 + if (!size) return size;
657 return {
658 width: Math.max(1, Math.round(size.width / tab.zoomFactor)),
659 height: Math.max(1, Math.round(size.height / tab.zoomFactor)),
@@ -622,7 +668,7 @@ const make = Effect.gen(function* () {
668 await tab.page.setViewportSize(size);
669 return;
670 }
625 - const layout = layoutSize(tab)!;
671 + const layout = (await layoutSize(tab))!;
672 await tab.cdp.send("Emulation.setDeviceMetricsOverride", {
673 width: layout.width,
674 height: layout.height,
@@ -631,9 +677,9 @@ const make = Effect.gen(function* () {
677 });
678 };
679
634 - const broadcastViewport = (tab: ServerTab) => {
635 - const size = layoutSize(tab);
636 - if (!size) return;
680 + const broadcastViewport = async (tab: ServerTab) => {
681 + const size = await layoutSize(tab);
682 + if (!size || tab.closing) return;
683 for (const viewer of tab.viewers) viewer.push({ _tag: "viewport", ...size });
684 };
685
@@ -650,7 +696,7 @@ const make = Effect.gen(function* () {
696 UNATTACHED_FILL_VIEWPORT;
697 await tab.page.setViewportSize({ width: size.width, height: size.height });
698 await applyZoom(tab);
653 - broadcastViewport(tab);
699 + await broadcastViewport(tab);
700 };
701
702 const applyRendering = async (tab: ServerTab, snapshot: PreviewSessionSnapshot) => {
@@ -663,7 +709,7 @@ const make = Effect.gen(function* () {
709 if (zoomFactor !== tab.zoomFactor && !tab.desktop) {
710 tab.zoomFactor = zoomFactor;
711 await applyZoom(tab);
666 - broadcastViewport(tab);
712 + await broadcastViewport(tab);
713 }
714 };
715
@@ -789,6 +835,9 @@ const make = Effect.gen(function* () {
835 setting: snapshot.viewport ?? FILL_PREVIEW_VIEWPORT,
836 colorScheme: "system",
837 zoomFactor: 1,
838 + desktopViewport: null,
839 + desktopViewportRead: Promise.resolve(null),
840 + desktopViewportNext: null,
841 loading: false,
842 closing: false,
843 recording: null,
@@ -803,6 +852,21 @@ const make = Effect.gen(function* () {
852 await page.setViewportSize(fixedViewportSize(tab.setting) ?? UNATTACHED_FILL_VIEWPORT);
853 }
854 await applyRendering(tab, snapshot);
855 + if (desktop) {
856 + // The desktop resizes and zooms its webview itself; viewers map input with the new size.
857 + const remeasure = () => {
858 + if (tab.viewers.size > 0) return broadcastViewport(tab).catch(constVoid);
859 + };
860 + cdp.on("Page.frameResized", remeasure);
861 + // A read a navigation broke has a fresh page to measure.
862 + cdp.on("Page.loadEventFired", remeasure);
863 + // Closing a dialog resizes nothing, and the host can close it without us.
864 + cdp.on("Page.javascriptDialogClosed", () => {
865 + tab.dialog = null;
866 + return remeasure();
867 + });
868 + await cdp.send("Page.enable");
869 + }
870 const isMainNavigation = (request: { isNavigationRequest(): boolean; frame(): unknown }) =>
871 request.isNavigationRequest() && request.frame() === page.mainFrame();
872 const navigationGenerations = new WeakMap<object, number>();
@@ -1383,7 +1447,7 @@ const make = Effect.gen(function* () {
1447 };
1448 }
1449 const url = tab.page.url();
1386 - const viewport = tab.page.viewportSize();
1450 + const viewport = tab.desktop ? await layoutSize(tab) : tab.page.viewportSize();
1451 const status = {
1452 available: true,
1453 visible: tab.viewers.size > 0,
@@ -2213,7 +2277,7 @@ const make = Effect.gen(function* () {
2277 const current = tab.page.viewportSize();
2278 if (current?.width === width && current.height === height) return;
2279 await tab.page.setViewportSize({ width, height });
2216 - broadcastViewport(tab);
2280 + await broadcastViewport(tab);
2281 return;
2282 }
2283 case "viewport": {
@@ -2313,15 +2377,22 @@ const make = Effect.gen(function* () {
2377 // Dropped frames must still release Chromium.
2378 if (Queue.offerUnsafe(output, next)) return;
2379 if (next._tag === "frame") runFork(next.ack);
2316 - // State a stalled viewer cannot miss replaces its backlog. It runs
2317 - // synchronously so an older replacement can never land after a newer one.
2318 - else if (next._tag === "gone" || next._tag === "control" || next._tag === "fileChooser") {
2380 + // State a stalled viewer cannot miss compacts its backlog. It runs
2381 + // synchronously so an older compaction can never land after a newer one.
2382 + else if (["gone", "reconnect", "control", "viewport", "fileChooser"].includes(next._tag)) {
2383 const dropped = Effect.runSyncExit(Queue.clear(output));
2384 if (dropped._tag === "Failure") return;
2321 - Queue.offerUnsafe(output, next);
2322 -
2323 - const chooser = next._tag === "control" ? fileChooserMessage(tab) : null;
2324 - if (chooser && tab.control.controller === viewer.id) Queue.offerUnsafe(output, chooser);
2385 + const items = [...dropped.value, next];
2386 + // Without its latest size and control the viewer cannot map input at all.
2387 + const state = (["control", "viewport"] as const).flatMap(
2388 + (tag) => items.findLast((item) => item._tag === tag) ?? [],
2389 + );
2390 + // Everything else is one-time; if it no longer fits, the oldest goes first.
2391 + const rest = items.filter(
2392 + (item) => item._tag !== "frame" && item._tag !== "control" && item._tag !== "viewport",
2393 + );
2394 + for (const item of [...rest.slice(state.length - VIEWER_OUTPUT_LIMIT), ...state])
2395 + Queue.offerUnsafe(output, item);
2396 for (const item of dropped.value) if (item._tag === "frame") runFork(item.ack);
2397 }
2398 },
@@ -2410,7 +2481,7 @@ const make = Effect.gen(function* () {
2481 ),
2482 });
2483 });
2413 - broadcastViewport(tab);
2484 + void broadcastViewport(tab).catch(constVoid);
2485 yield* Effect.promise(() => startScreencast(1));
2486 // An idle page does not repaint for a new screencast, so the viewer
2487 // starts from a still unless a live frame beat it.