From fffb0a7a28af964539c7477e322b633fb5925493 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 11 Nov 2026 06:05:02 +0000 Subject: [PATCH 1/5] test(server): a busy embedded frame holds a copy key back from the page Fails on main: the server reads every frame's copy recorder before it dispatches a copy key, so a frame that does not answer keeps the key from the page. Repro for #34186. AI-assisted; verified with the tests and tools listed above. --- apps/server/src/preview/ServerBrowser.test.ts | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/apps/server/src/preview/ServerBrowser.test.ts b/apps/server/src/preview/ServerBrowser.test.ts index c32947b30b995..a607f3bd11138 100644 --- a/apps/server/src/preview/ServerBrowser.test.ts +++ b/apps/server/src/preview/ServerBrowser.test.ts @@ -1409,6 +1409,45 @@ it.live("only the controlling viewer's copy and cut keys reach its clipboard", ( ).pipe(Effect.provide(layer)), ); +it.live("a busy embedded frame does not hold a copy key back from the page", () => + Effect.scoped( + Effect.gen(function* () { + const { browser, tabId } = yield* ready; + const context = contexts[0]!; + const viewer = yield* browser.attachViewer(viewerInput(tabId, true)); + yield* viewer.input({ type: "takeControl" }); + const pageSession = context.sessions.at(-1)!; + const frame = makeFrame(); + context.page.emit("framenavigated", frame); + yield* Effect.promise(() => frame.recording.promise); + + // The frame answers its copy read only once the page has the key, like a + // frame busy for longer than the user waits. + const keyReached = Promise.withResolvers(); + const pageSend = pageSession.send.getMockImplementation()!; + pageSession.send.mockImplementation(async (method, input) => { + if (method === "Input.dispatchKeyEvent") keyReached.resolve(); + return pageSend(method, input); + }); + const frameSession = context.sessions.at(-1)!; + const frameSend = frameSession.send.getMockImplementation()!; + frameSession.send.mockImplementation(async (method, input) => { + if (method === "Runtime.evaluate" && (input as { contextId?: number }).contextId === 7) { + await keyReached.promise; + } + return frameSend(method, input); + }); + + keyCopy = "copied"; + yield* viewer.input({ type: "key", action: "down", key: "c", code: "KeyC", modifiers: 4 }); + expect(pageSession.send).toHaveBeenCalledWith( + "Input.dispatchKeyEvent", + expect.objectContaining({ key: "c", commands: ["copy"] }), + ); + }), + ).pipe(Effect.provide(layer)), +); + it.live.each([false, true])( "a page download is saved, offered to the controller, and listed for the agent (delete fails: %s)", (deleteFails) => From b6e0b788803e7bff72d18ebe3001f250732ba715 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 11 Nov 2026 06:14:48 +0000 Subject: [PATCH 2/5] fix(server): a busy embedded frame no longer holds copy keys back The streamed Browser read every frame's copy recorder before sending a copy or cut key, so a frame busy running script kept the key from a responsive page. The recorder now stamps each copy with its key's time and the read after the key takes only copies made since that key was sent, so the read before the key is gone. That read also runs after the key leaves the input queue, so a late frame no longer holds the next key or click either. Fixes pingdotgg/t3code#34186 AI-assisted; verified with the tests and tools listed above. --- apps/server/src/preview/ServerBrowser.test.ts | 10 +++-- apps/server/src/preview/ServerBrowser.ts | 37 ++++++++++++------- 2 files changed, 30 insertions(+), 17 deletions(-) diff --git a/apps/server/src/preview/ServerBrowser.test.ts b/apps/server/src/preview/ServerBrowser.test.ts index a607f3bd11138..17ed3a5955ea0 100644 --- a/apps/server/src/preview/ServerBrowser.test.ts +++ b/apps/server/src/preview/ServerBrowser.test.ts @@ -129,9 +129,13 @@ function makeSession( return { result: { value: [] } }; } if (method === "Page.addScriptToEvaluateOnNewDocument") frame?.recording.resolve(); - if (method === "Input.dispatchKeyEvent" && (input as { commands?: unknown }).commands) { - if (focusedFrame) focusedFrame.copy = keyCopy || focusedFrame.copy; - else pageCopy = keyCopy || pageCopy; + // The recorder drops its last copy on every copy or cut key it sees. + if ( + method === "Input.dispatchKeyEvent" && + ["copy", "cut"].includes((input as { commands?: Array }).commands?.[0] ?? "") + ) { + if (focusedFrame) focusedFrame.copy = keyCopy; + else pageCopy = keyCopy; } if (method === "Runtime.evaluate" && (input as { contextId?: number }).contextId === 7) { const value = frame ? frame.copy : pageCopy; diff --git a/apps/server/src/preview/ServerBrowser.ts b/apps/server/src/preview/ServerBrowser.ts index ee31b17cc5889..95dba73925455 100644 --- a/apps/server/src/preview/ServerBrowser.ts +++ b/apps/server/src/preview/ServerBrowser.ts @@ -427,6 +427,7 @@ const CLIPBOARD_WORLD = "t3-preview-clipboard"; // Chromium shares its clipboard across contexts; capture real copy/cut keys in a page-inaccessible world instead. const CLIPBOARD_SCRIPT = `(() => { let keying = false; + let keyedAt = 0; let copied = ""; // The same Ctrl or Cmd + C or X that editingCommand sends as copy or cut. addEventListener("keydown", (event) => { @@ -434,6 +435,7 @@ const CLIPBOARD_SCRIPT = `(() => { const key = event.key.toLowerCase(); if (key !== "c" && key !== "x") return; keying = true; + keyedAt = Date.now(); copied = ""; setTimeout(() => { keying = false; }); }, true); @@ -460,8 +462,9 @@ const CLIPBOARD_SCRIPT = `(() => { addEventListener(type, snapshot, true); addEventListener(type, replace); } - globalThis.takeCopy = () => { - const text = copied; + // Only a key dispatched at or after since made this copy; older ones are stale. + globalThis.takeCopy = (since) => { + const text = keyedAt >= since ? copied : ""; copied = ""; return text; }; @@ -1310,7 +1313,7 @@ const make = Effect.gen(function* () { await recordCopies(cdp).catch(constVoid); }; - const takeSessionCopies = async (cdp: CDPSession) => { + const takeSessionCopies = async (cdp: CDPSession, since: number) => { const tree = await cdp.send("Page.getFrameTree").catch(() => null); if (!tree) return []; const frameIds = (node: typeof tree.frameTree): Array => [ @@ -1324,7 +1327,7 @@ const make = Effect.gen(function* () { .then(({ executionContextId }) => cdp.send("Runtime.evaluate", { contextId: executionContextId, - expression: "globalThis.takeCopy?.()", + expression: `globalThis.takeCopy?.(${since})`, returnByValue: true, }), ) @@ -1336,9 +1339,9 @@ const make = Effect.gen(function* () { ); }; - const takeCopiedText = async (tab: ServerTab) => { + const takeCopiedText = async (tab: ServerTab, since: number) => { const copies = await Promise.all( - [tab.cdp, ...tab.frameSessions.values()].map(takeSessionCopies), + [tab.cdp, ...tab.frameSessions.values()].map((cdp) => takeSessionCopies(cdp, since)), ); return copies.flat().find((text) => text.length > 0); }; @@ -2447,7 +2450,7 @@ const make = Effect.gen(function* () { const copying = !tab.desktop && (command?.commands[0] === "copy" || command?.commands[0] === "cut"); - if (copying) await takeCopiedText(tab); + const since = Date.now(); await session.send("Input.dispatchKeyEvent", { type: text ? "keyDown" : "rawKeyDown", key, @@ -2461,10 +2464,12 @@ const make = Effect.gen(function* () { ), }); viewer.pressedKeys.set(code || key, { key, code }); - if (copying) { - const copied = await takeCopiedText(tab); - if (copied) viewer.push({ _tag: "clipboard", text: copied }); - } + // Read outside the input queue: a busy frame answers late and must not hold later input. + if (copying) + return async () => { + const copied = await takeCopiedText(tab, since); + if (copied) viewer.push({ _tag: "clipboard", text: copied }); + }; return; } case "text": @@ -2721,8 +2726,9 @@ const make = Effect.gen(function* () { : {}), }); } else { - const dispatch = (input: Record) => - dispatchViewerInput(tab, session, viewer, input); + const dispatch = async (input: Record) => { + await dispatchViewerInput(tab, session, viewer, input); + }; if ( message.type === "mouse" && message.action === "move" && @@ -2749,7 +2755,10 @@ const make = Effect.gen(function* () { }), ); } else { - await tab.control.human(viewer.id, () => dispatch(message)); + const readCopy = await tab.control.human(viewer.id, () => + dispatchViewerInput(tab, session, viewer, message), + ); + await readCopy?.(); } } } catch { From 77548189093390196a02130f93eef0a3aa45cfca Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 11 Nov 2026 06:30:56 +0000 Subject: [PATCH 3/5] fix(server): read a copy key's result before the next key The copy recorder in each frame holds one result, so reading it after the key had left the input queue let a second copy or cut key clear the first one's text before it was read. Read it inside the queue again, as before; the busy-frame wait before the key stays gone. AI-assisted; verified with the tests and tools listed above. --- apps/server/src/preview/ServerBrowser.ts | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/apps/server/src/preview/ServerBrowser.ts b/apps/server/src/preview/ServerBrowser.ts index 95dba73925455..5c9455d618aca 100644 --- a/apps/server/src/preview/ServerBrowser.ts +++ b/apps/server/src/preview/ServerBrowser.ts @@ -2464,12 +2464,10 @@ const make = Effect.gen(function* () { ), }); viewer.pressedKeys.set(code || key, { key, code }); - // Read outside the input queue: a busy frame answers late and must not hold later input. - if (copying) - return async () => { - const copied = await takeCopiedText(tab, since); - if (copied) viewer.push({ _tag: "clipboard", text: copied }); - }; + if (copying) { + const copied = await takeCopiedText(tab, since); + if (copied) viewer.push({ _tag: "clipboard", text: copied }); + } return; } case "text": @@ -2726,9 +2724,8 @@ const make = Effect.gen(function* () { : {}), }); } else { - const dispatch = async (input: Record) => { - await dispatchViewerInput(tab, session, viewer, input); - }; + const dispatch = (input: Record) => + dispatchViewerInput(tab, session, viewer, input); if ( message.type === "mouse" && message.action === "move" && @@ -2755,10 +2752,7 @@ const make = Effect.gen(function* () { }), ); } else { - const readCopy = await tab.control.human(viewer.id, () => - dispatchViewerInput(tab, session, viewer, message), - ); - await readCopy?.(); + await tab.control.human(viewer.id, () => dispatch(message)); } } } catch { From 8ce3250378cb91d3fd0b90bb4cf87bd5c65a83fe Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 11 Nov 2026 07:37:23 +0000 Subject: [PATCH 4/5] fix(server): input after a copy key no longer waits for a busy frame Reading the copy recorder inside the input queue held every key and click after a copy or cut until a busy embedded frame answered. The read now runs after the key leaves the queue, one read at a time in key order. The recorder keeps one entry per copy or cut key instead of a single slot, so a later key cannot overwrite a copy that has not been read yet. Each read drops entries from keys sent before its own key and takes the oldest one left. AI-assisted; verified with the tests and tools listed above. --- apps/server/src/preview/ServerBrowser.test.ts | 17 ++++++-- apps/server/src/preview/ServerBrowser.ts | 39 ++++++++++++------- 2 files changed, 37 insertions(+), 19 deletions(-) diff --git a/apps/server/src/preview/ServerBrowser.test.ts b/apps/server/src/preview/ServerBrowser.test.ts index 17ed3a5955ea0..89d0d5a12728b 100644 --- a/apps/server/src/preview/ServerBrowser.test.ts +++ b/apps/server/src/preview/ServerBrowser.test.ts @@ -1425,12 +1425,13 @@ it.live("a busy embedded frame does not hold a copy key back from the page", () context.page.emit("framenavigated", frame); yield* Effect.promise(() => frame.recording.promise); - // The frame answers its copy read only once the page has the key, like a - // frame busy for longer than the user waits. + // The frame answers its copy read only once the page has the key and the + // input after it, like a frame busy for longer than the user waits. const keyReached = Promise.withResolvers(); const pageSend = pageSession.send.getMockImplementation()!; pageSession.send.mockImplementation(async (method, input) => { - if (method === "Input.dispatchKeyEvent") keyReached.resolve(); + if (method === "Input.dispatchKeyEvent" && (input as { type?: string }).type === "keyUp") + keyReached.resolve(); return pageSend(method, input); }); const frameSession = context.sessions.at(-1)!; @@ -1443,11 +1444,19 @@ it.live("a busy embedded frame does not hold a copy key back from the page", () }); keyCopy = "copied"; - yield* viewer.input({ type: "key", action: "down", key: "c", code: "KeyC", modifiers: 4 }); + const copying = yield* viewer + .input({ type: "key", action: "down", key: "c", code: "KeyC", modifiers: 4 }) + .pipe(Effect.forkScoped({ startImmediately: true })); + yield* viewer.input({ type: "key", action: "up", key: "c", code: "KeyC", modifiers: 4 }); + yield* Fiber.join(copying); expect(pageSession.send).toHaveBeenCalledWith( "Input.dispatchKeyEvent", expect.objectContaining({ key: "c", commands: ["copy"] }), ); + const clipboard = yield* Queue.clear(viewer.output); + expect(clipboard.filter((item) => item._tag === "clipboard")).toEqual([ + { _tag: "clipboard", text: "copied" }, + ]); }), ).pipe(Effect.provide(layer)), ); diff --git a/apps/server/src/preview/ServerBrowser.ts b/apps/server/src/preview/ServerBrowser.ts index 5c9455d618aca..519347cb832f9 100644 --- a/apps/server/src/preview/ServerBrowser.ts +++ b/apps/server/src/preview/ServerBrowser.ts @@ -295,6 +295,8 @@ interface ServerTab { readonly page: Page; readonly cdp: CDPSession; readonly frameSessions: Map; + /** Copy reads run in key order, outside the input queue. */ + copyReads: Promise; readonly createdAt: number; usedAt: number; readonly viewers: Set; @@ -427,16 +429,15 @@ const CLIPBOARD_WORLD = "t3-preview-clipboard"; // Chromium shares its clipboard across contexts; capture real copy/cut keys in a page-inaccessible world instead. const CLIPBOARD_SCRIPT = `(() => { let keying = false; - let keyedAt = 0; - let copied = ""; + // One entry per copy or cut key, oldest first, so a later key cannot overwrite an unread copy. + const copies = []; // The same Ctrl or Cmd + C or X that editingCommand sends as copy or cut. addEventListener("keydown", (event) => { if (!event.isTrusted || event.altKey || event.ctrlKey === event.metaKey) return; const key = event.key.toLowerCase(); if (key !== "c" && key !== "x") return; keying = true; - keyedAt = Date.now(); - copied = ""; + copies.push({ at: Date.now(), text: "" }); setTimeout(() => { keying = false; }); }, true); const selection = () => { @@ -447,7 +448,8 @@ const CLIPBOARD_SCRIPT = `(() => { return String(document.getSelection() ?? ""); }; const record = (text) => { - copied = String(text ?? "").slice(0, ${CLIPBOARD_TEXT_LIMIT}); + const copy = copies.at(-1); + if (copy) copy.text = String(text ?? "").slice(0, ${CLIPBOARD_TEXT_LIMIT}); }; // Capturing at window runs before page handlers can stop the event, and // before cut removes the selection. @@ -462,11 +464,10 @@ const CLIPBOARD_SCRIPT = `(() => { addEventListener(type, snapshot, true); addEventListener(type, replace); } - // Only a key dispatched at or after since made this copy; older ones are stale. + // Copies from keys dispatched before since are stale. globalThis.takeCopy = (since) => { - const text = keyedAt >= since ? copied : ""; - copied = ""; - return text; + while (copies.length > 0 && copies[0].at < since) copies.shift(); + return copies.shift()?.text ?? ""; }; })();`; @@ -870,6 +871,7 @@ const make = Effect.gen(function* () { page, cdp, frameSessions: new Map(), + copyReads: Promise.resolve(), createdAt: Date.now(), usedAt: Date.now(), viewers: new Set(), @@ -2464,11 +2466,14 @@ const make = Effect.gen(function* () { ), }); viewer.pressedKeys.set(code || key, { key, code }); - if (copying) { + if (!copying) return; + // A busy frame answers late; its read must not hold later input. + const read = tab.copyReads.then(async () => { const copied = await takeCopiedText(tab, since); if (copied) viewer.push({ _tag: "clipboard", text: copied }); - } - return; + }); + tab.copyReads = read; + return () => read; } case "text": if (typeof message.text === "string" && message.text.length > 0) { @@ -2724,8 +2729,9 @@ const make = Effect.gen(function* () { : {}), }); } else { - const dispatch = (input: Record) => - dispatchViewerInput(tab, session, viewer, input); + const dispatch = async (input: Record) => { + await dispatchViewerInput(tab, session, viewer, input); + }; if ( message.type === "mouse" && message.action === "move" && @@ -2752,7 +2758,10 @@ const make = Effect.gen(function* () { }), ); } else { - await tab.control.human(viewer.id, () => dispatch(message)); + const copyRead = await tab.control.human(viewer.id, () => + dispatchViewerInput(tab, session, viewer, message), + ); + await copyRead?.(); } } } catch { From f5f438fb175a6f2dc4d07b5ea15e5eceff921fdd Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 11 Nov 2026 07:53:32 +0000 Subject: [PATCH 5/5] fix(server): each copy read takes only its own key's copy A read took every frame's oldest copy since its key was sent, so a read held up by a busy frame could also consume a later key's copy in another frame and drop it. Each copy or cut key now gets its own millisecond window, from just before it is sent to its acknowledgement, and the next one starts after it. A read only takes a copy keyed inside its window. AI-assisted; verified with the tests and tools listed above. --- apps/server/src/preview/ServerBrowser.ts | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/apps/server/src/preview/ServerBrowser.ts b/apps/server/src/preview/ServerBrowser.ts index 519347cb832f9..c6ff6d51a3f23 100644 --- a/apps/server/src/preview/ServerBrowser.ts +++ b/apps/server/src/preview/ServerBrowser.ts @@ -297,6 +297,8 @@ interface ServerTab { readonly frameSessions: Map; /** Copy reads run in key order, outside the input queue. */ copyReads: Promise; + /** When the last copy or cut key was acknowledged; the next one starts after it. */ + copyKeyedUntil: number; readonly createdAt: number; usedAt: number; readonly viewers: Set; @@ -464,10 +466,10 @@ const CLIPBOARD_SCRIPT = `(() => { addEventListener(type, snapshot, true); addEventListener(type, replace); } - // Copies from keys dispatched before since are stale. - globalThis.takeCopy = (since) => { + // A key's copy was keyed between its dispatch and acknowledgement; older copies are stale. + globalThis.takeCopy = (since, until) => { while (copies.length > 0 && copies[0].at < since) copies.shift(); - return copies.shift()?.text ?? ""; + return copies[0] && copies[0].at <= until ? copies.shift().text : ""; }; })();`; @@ -872,6 +874,7 @@ const make = Effect.gen(function* () { cdp, frameSessions: new Map(), copyReads: Promise.resolve(), + copyKeyedUntil: 0, createdAt: Date.now(), usedAt: Date.now(), viewers: new Set(), @@ -1315,7 +1318,7 @@ const make = Effect.gen(function* () { await recordCopies(cdp).catch(constVoid); }; - const takeSessionCopies = async (cdp: CDPSession, since: number) => { + const takeSessionCopies = async (cdp: CDPSession, since: number, until: number) => { const tree = await cdp.send("Page.getFrameTree").catch(() => null); if (!tree) return []; const frameIds = (node: typeof tree.frameTree): Array => [ @@ -1329,7 +1332,7 @@ const make = Effect.gen(function* () { .then(({ executionContextId }) => cdp.send("Runtime.evaluate", { contextId: executionContextId, - expression: `globalThis.takeCopy?.(${since})`, + expression: `globalThis.takeCopy?.(${since}, ${until})`, returnByValue: true, }), ) @@ -1341,9 +1344,9 @@ const make = Effect.gen(function* () { ); }; - const takeCopiedText = async (tab: ServerTab, since: number) => { + const takeCopiedText = async (tab: ServerTab, since: number, until: number) => { const copies = await Promise.all( - [tab.cdp, ...tab.frameSessions.values()].map((cdp) => takeSessionCopies(cdp, since)), + [tab.cdp, ...tab.frameSessions.values()].map((cdp) => takeSessionCopies(cdp, since, until)), ); return copies.flat().find((text) => text.length > 0); }; @@ -2452,6 +2455,9 @@ const make = Effect.gen(function* () { const copying = !tab.desktop && (command?.commands[0] === "copy" || command?.commands[0] === "cut"); + // Copy keys get disjoint millisecond windows so each frame's copy belongs to one key. + if (copying) + while (Date.now() <= tab.copyKeyedUntil) await sleepUntil(tab.copyKeyedUntil + 1); const since = Date.now(); await session.send("Input.dispatchKeyEvent", { type: text ? "keyDown" : "rawKeyDown", @@ -2467,9 +2473,11 @@ const make = Effect.gen(function* () { }); viewer.pressedKeys.set(code || key, { key, code }); if (!copying) return; + const until = Date.now(); + tab.copyKeyedUntil = until; // A busy frame answers late; its read must not hold later input. const read = tab.copyReads.then(async () => { - const copied = await takeCopiedText(tab, since); + const copied = await takeCopiedText(tab, since, until); if (copied) viewer.push({ _tag: "clipboard", text: copied }); }); tab.copyReads = read;