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.