stageflow 0.32.0 → 0.35.0

package/dist/browser/agentBrowserLiveViewRelay.js

@@ -0,0 +1,801 @@
+export const DEFAULT_MAX_INPUT_BATCH = 64;
+export const DEFAULT_MAX_INPUT_EVENTS_PER_SECOND = 500;
+const MAX_COORDINATE = 20_000;
+const MAX_DELTA = 100_000;
+const MAX_TEXT_LENGTH = 32;
+const MAX_TOUCH_POINTS = 10;
+const STATUS_TIMEOUT_MS = 10_000;
+const MAX_QUEUED_BATCHES = 16;
+const TAB_LIST_TRIES = 5;
+const RECONNECT_TRIES = 3;
+const RETARGET_ATTEMPTS = 2;
+const DEFAULT_FIRST_FRAME_TIMEOUT_MS = 1500;
+export const DEFAULT_REOPEN_MIN_INTERVAL_MS = 2000;
+const REOPEN_WAIT_TRIES = 50;
+const FORWARDED = new Set(["frame", "status", "tabs", "url"]);
+const DEFAULT_DIALOG_TIMEOUT_MS = 60_000;
+const MAX_DIALOG_TEXT = 2000;
+const MAX_DIALOG_ID = 64;
+const DIALOG_KINDS = ["alert", "confirm", "prompt", "beforeunload"];
+const CDP_NO_DIALOG = -32602;
+const REPLAYED = ["status", "tabs", "url", "frame"];
+export class LiveViewRelayError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "LiveViewRelayError";
+    }
+}
+const WS_OPEN = 1;
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function onlyKeys(value, allowed) {
+    return Object.keys(value).every((key) => allowed.includes(key));
+}
+function oneOf(value, options) {
+    return typeof value === "string" && options.includes(value);
+}
+function isNumberIn(value, min, max) {
+    return typeof value === "number" && Number.isFinite(value) && value >= min && value <= max;
+}
+function isIntIn(value, min, max) {
+    return isNumberIn(value, min, max) && Number.isInteger(value);
+}
+function optional(value, check) {
+    return value === undefined || check(value);
+}
+function shortString(value) {
+    return typeof value === "string" && value.length <= MAX_TEXT_LENGTH;
+}
+function validMouse(e) {
+    return (onlyKeys(e, ["type", "eventType", "x", "y", "button", "clickCount", "deltaX", "deltaY", "modifiers"]) &&
+        oneOf(e.eventType, ["mousePressed", "mouseReleased", "mouseMoved", "mouseWheel"]) &&
+        isNumberIn(e.x, 0, MAX_COORDINATE) &&
+        isNumberIn(e.y, 0, MAX_COORDINATE) &&
+        optional(e.button, (v) => oneOf(v, ["left", "middle", "right"])) &&
+        optional(e.clickCount, (v) => isIntIn(v, 0, 3)) &&
+        optional(e.deltaX, (v) => isNumberIn(v, -MAX_DELTA, MAX_DELTA)) &&
+        optional(e.deltaY, (v) => isNumberIn(v, -MAX_DELTA, MAX_DELTA)) &&
+        optional(e.modifiers, (v) => isIntIn(v, 0, 15)));
+}
+function validKeyboard(e) {
+    return (onlyKeys(e, ["type", "eventType", "key", "code", "text", "windowsVirtualKeyCode", "modifiers"]) &&
+        oneOf(e.eventType, ["keyDown", "keyUp", "char"]) &&
+        optional(e.key, shortString) &&
+        optional(e.code, shortString) &&
+        optional(e.text, shortString) &&
+        optional(e.windowsVirtualKeyCode, (v) => isIntIn(v, 0, 255)) &&
+        optional(e.modifiers, (v) => isIntIn(v, 0, 15)));
+}
+function validTouchPoint(p) {
+    return (isPlainObject(p) &&
+        onlyKeys(p, ["x", "y", "id"]) &&
+        isNumberIn(p.x, 0, MAX_COORDINATE) &&
+        isNumberIn(p.y, 0, MAX_COORDINATE) &&
+        optional(p.id, (v) => isIntIn(v, 0, 1_000_000)));
+}
+function validTouch(e) {
+    return (onlyKeys(e, ["type", "eventType", "touchPoints", "modifiers"]) &&
+        oneOf(e.eventType, ["touchStart", "touchMove", "touchEnd", "touchCancel"]) &&
+        Array.isArray(e.touchPoints) &&
+        e.touchPoints.length <= MAX_TOUCH_POINTS &&
+        e.touchPoints.every(validTouchPoint) &&
+        optional(e.modifiers, (v) => isIntIn(v, 0, 15)));
+}
+export function validEvent(event) {
+    if (!isPlainObject(event))
+        return false;
+    switch (event.type) {
+        case "input_mouse":
+            return validMouse(event);
+        case "input_keyboard":
+            return validKeyboard(event);
+        case "input_touch":
+            return validTouch(event);
+        default:
+            return false;
+    }
+}
+async function readStreamPort(runner, env) {
+    let result;
+    try {
+        result = await runner(["stream", "status", "--json"], env, { timeoutMs: STATUS_TIMEOUT_MS });
+    }
+    catch {
+        return undefined;
+    }
+    if (result.code !== 0)
+        return undefined;
+    try {
+        const parsed = JSON.parse(result.stdout ?? "");
+        const data = isPlainObject(parsed) && isPlainObject(parsed.data) ? parsed.data : undefined;
+        const port = data?.port;
+        if (data?.enabled === false)
+            return undefined;
+        return typeof port === "number" && Number.isInteger(port) && port > 0 && port < 65536
+            ? port
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function findStreamPort(runner, env) {
+    let port = await readStreamPort(runner, env);
+    if (port === undefined) {
+        try {
+            await runner(["stream", "enable", "--json"], env, { timeoutMs: STATUS_TIMEOUT_MS });
+        }
+        catch {
+            // the follow-up status read decides
+        }
+        port = await readStreamPort(runner, env);
+    }
+    if (port === undefined) {
+        throw new LiveViewRelayError("stream_port_unavailable", "agent-browser did not report a stream port");
+    }
+    return port;
+}
+function connect(Impl, url) {
+    return new Promise((resolve, reject) => {
+        let ws;
+        const fail = () => reject(new LiveViewRelayError("stream_connect_failed", "could not connect to the browser stream"));
+        try {
+            ws = new Impl(url);
+        }
+        catch {
+            fail();
+            return;
+        }
+        ws.onopen = () => resolve(ws);
+        ws.onerror = fail;
+        ws.onclose = fail;
+    });
+}
+const streamUrl = (port) => `ws://127.0.0.1:${port}`;
+async function readCdpAddress(runner, request) {
+    const known = request.cdpAddress ?? request.env.AGENT_BROWSER_CDP;
+    if (known !== undefined)
+        return known;
+    try {
+        const result = await runner(["get", "cdp-url"], request.env, { timeoutMs: STATUS_TIMEOUT_MS });
+        const out = (result.stdout ?? "").trim();
+        return result.code === 0 && /^wss?:\/\//.test(out) ? out : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function findTab(stdout, targetId) {
+    try {
+        const parsed = JSON.parse(stdout ?? "");
+        const tabs = isPlainObject(parsed) && isPlainObject(parsed.data) ? parsed.data.tabs : undefined;
+        if (!Array.isArray(tabs))
+            return undefined;
+        for (const tab of tabs) {
+            if (isPlainObject(tab) && tab.targetId === targetId && typeof tab.tabId === "string") {
+                return { tabId: tab.tabId, url: typeof tab.url === "string" ? tab.url : "" };
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+const clip = (value) => typeof value === "string" ? value.slice(0, MAX_DIALOG_TEXT) : "";
+export function createAgentBrowserLiveViewRelay(options) {
+    const Impl = options.WebSocketImpl ?? globalThis.WebSocket;
+    const maxBatch = options.maxBatch ?? DEFAULT_MAX_INPUT_BATCH;
+    const maxPerSecond = options.maxEventsPerSecond ?? DEFAULT_MAX_INPUT_EVENTS_PER_SECOND;
+    const now = options.now ?? Date.now;
+    const retryDelayMs = options.retryDelayMs ?? 100;
+    const reopenMinIntervalMs = options.reopenMinIntervalMs ?? DEFAULT_REOPEN_MIN_INTERVAL_MS;
+    const dialogTimeoutMs = options.dialogTimeoutMs ?? DEFAULT_DIALOG_TIMEOUT_MS;
+    const firstFrameTimeoutMs = options.firstFrameTimeoutMs ?? DEFAULT_FIRST_FRAME_TIMEOUT_MS;
+    const schedule = options.schedule ??
+        ((fn, ms) => {
+            const timer = setTimeout(fn, ms);
+            return () => clearTimeout(timer);
+        });
+    return {
+        async open(request) {
+            const port = await findStreamPort(options.runner, request.env);
+            let ws = await connect(Impl, streamUrl(port));
+            const cdpAddress = await readCdpAddress(options.runner, request);
+            let cdp;
+            if (cdpAddress !== undefined) {
+                cdp = await connect(Impl, cdpAddress).catch(() => undefined);
+            }
+            const subscribers = new Set();
+            const latest = new Map();
+            const timers = new Set();
+            const queued = [];
+            const pages = new Map();
+            let current;
+            let desired;
+            let running = false;
+            let retargeting = false;
+            let closed = false;
+            let frameSeen = false;
+            let cancelNudge;
+            const targetSessions = new Map();
+            const sessionTargets = new Map();
+            const openDialogs = new Map();
+            const cdpPending = new Map();
+            let reopening = false;
+            let lastReopenAt;
+            let dialogSeq = 0;
+            let cdpSeq = 0;
+            let windowStart = now();
+            let windowCount = 0;
+            const dropSocket = (socket) => {
+                if (socket === undefined)
+                    return;
+                socket.onopen = socket.onmessage = socket.onerror = socket.onclose = null;
+                try {
+                    socket.close();
+                }
+                catch {
+                    // already closing
+                }
+            };
+            const finish = (reason) => {
+                if (closed)
+                    return;
+                closed = true;
+                cancelNudge?.();
+                for (const open of openDialogs.values())
+                    open.cancelTimer?.();
+                openDialogs.clear();
+                dropSocket(ws);
+                dropSocket(cdp);
+                ws = cdp = undefined;
+                for (const done of [...cdpPending.values()])
+                    done(undefined);
+                cdpPending.clear();
+                for (const { timer, done } of [...timers]) {
+                    clearTimeout(timer);
+                    done();
+                }
+                timers.clear();
+                for (const batch of queued.splice(0))
+                    batch.done({ ok: false, reason: "closed" });
+                desired = undefined;
+                const message = { type: "closed", data: { reason } };
+                const targets = [...subscribers];
+                subscribers.clear();
+                latest.clear();
+                for (const subscriber of targets)
+                    subscriber(message);
+            };
+            const pause = () => new Promise((resolve) => {
+                const entry = {
+                    timer: setTimeout(() => {
+                        timers.delete(entry);
+                        resolve();
+                    }, retryDelayMs),
+                    done: resolve,
+                };
+                timers.add(entry);
+            });
+            const broadcast = (message) => {
+                for (const subscriber of [...subscribers])
+                    subscriber(message);
+            };
+            const cdpSend = (method, params, sessionId) => {
+                const socket = cdp;
+                if (socket === undefined || socket.readyState !== WS_OPEN)
+                    return undefined;
+                const id = ++cdpSeq;
+                try {
+                    socket.send(JSON.stringify({ id, method, params, sessionId }));
+                }
+                catch {
+                    return undefined;
+                }
+                return id;
+            };
+            const cdpCall = (method, params, sessionId) => new Promise((resolve) => {
+                const id = cdpSend(method, params, sessionId);
+                if (id === undefined) {
+                    resolve(undefined);
+                    return;
+                }
+                cdpPending.set(id, resolve);
+            });
+            const endDialog = (open, result) => {
+                if (openDialogs.get(open.dialog.id) !== open)
+                    return;
+                openDialogs.delete(open.dialog.id);
+                open.cancelTimer?.();
+                broadcast({ type: "dialog_closed", data: { id: open.dialog.id, result } });
+            };
+            const endDialogsWhere = (match, result) => {
+                for (const open of [...openDialogs.values()])
+                    if (match(open))
+                        endDialog(open, result);
+            };
+            const expireDialog = async (open) => {
+                open.cancelTimer = undefined;
+                if (open.answered || openDialogs.get(open.dialog.id) !== open)
+                    return;
+                open.answered = true;
+                const reply = await cdpCall("Page.handleJavaScriptDialog", { accept: false }, open.sessionId);
+                if (reply === undefined)
+                    return;
+                if (reply.error === undefined || reply.error.code === CDP_NO_DIALOG)
+                    endDialog(open, "timeout");
+            };
+            const onDialogOpening = (sessionId, params) => {
+                const targetId = sessionTargets.get(sessionId);
+                if (targetId === undefined || typeof params.type !== "string" || !DIALOG_KINDS.includes(params.type))
+                    return;
+                endDialogsWhere((open) => open.sessionId === sessionId, "closed_by_page");
+                const kind = params.type;
+                const answerable = kind === "confirm" || kind === "prompt";
+                const dialog = {
+                    id: `d${++dialogSeq}`,
+                    kind,
+                    message: clip(params.message),
+                    defaultPrompt: clip(params.defaultPrompt),
+                    targetId,
+                    answerable,
+                };
+                const open = { dialog, sessionId, answered: false };
+                openDialogs.set(dialog.id, open);
+                if (answerable)
+                    open.cancelTimer = schedule(() => void expireDialog(open), dialogTimeoutMs);
+                broadcast({ type: "dialog", data: dialog });
+            };
+            const onDialogClosed = (sessionId, params) => {
+                endDialogsWhere((open) => open.sessionId === sessionId, params.result === true ? "accepted" : "dismissed");
+            };
+            const onAttached = (params) => {
+                const sessionId = params.sessionId;
+                if (typeof sessionId !== "string")
+                    return;
+                const info = params.targetInfo;
+                if (isPlainObject(info) && info.type === "page" && typeof info.targetId === "string") {
+                    targetSessions.set(info.targetId, sessionId);
+                    sessionTargets.set(sessionId, info.targetId);
+                    cdpSend("Page.enable", {}, sessionId);
+                }
+                if (params.waitingForDebugger === true)
+                    cdpSend("Runtime.runIfWaitingForDebugger", {}, sessionId);
+            };
+            const onDetached = (params) => {
+                const sessionId = params.sessionId;
+                if (typeof sessionId !== "string")
+                    return;
+                const targetId = sessionTargets.get(sessionId);
+                sessionTargets.delete(sessionId);
+                if (targetId !== undefined && targetSessions.get(targetId) === sessionId)
+                    targetSessions.delete(targetId);
+                endDialogsWhere((open) => open.sessionId === sessionId, "closed_by_page");
+            };
+            const attachStream = (socket) => {
+                socket.onmessage = (event) => {
+                    if (closed || typeof event.data !== "string")
+                        return;
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(event.data);
+                    }
+                    catch {
+                        return;
+                    }
+                    if (!isPlainObject(parsed) || typeof parsed.type !== "string")
+                        return;
+                    if (!FORWARDED.has(parsed.type))
+                        return;
+                    if (parsed.type === "frame")
+                        frameSeen = true;
+                    const { type, ...data } = parsed;
+                    const message = { type, data };
+                    latest.set(type, message);
+                    for (const subscriber of [...subscribers])
+                        subscriber(message);
+                };
+                socket.onclose = () => finish("upstream_closed");
+            };
+            attachStream(ws);
+            const run = async (args) => {
+                try {
+                    return await options.runner(args, request.env, { timeoutMs: STATUS_TIMEOUT_MS });
+                }
+                catch {
+                    return undefined;
+                }
+            };
+            const resolveTab = async (target) => {
+                for (let i = 0; i < TAB_LIST_TRIES && !closed; i++) {
+                    const listed = await run(["tab", "--json"]);
+                    if (listed === undefined || listed.code !== 0)
+                        return undefined;
+                    const tab = findTab(listed.stdout, target);
+                    if (tab !== undefined)
+                        return tab;
+                    if (i < TAB_LIST_TRIES - 1)
+                        await pause();
+                }
+                return undefined;
+            };
+            const reconnect = async () => {
+                for (let i = 0; i < RECONNECT_TRIES && !closed; i++) {
+                    try {
+                        return await connect(Impl, streamUrl(port));
+                    }
+                    catch {
+                        if (i < RECONNECT_TRIES - 1)
+                            await pause();
+                    }
+                }
+                return undefined;
+            };
+            const restartStream = async () => {
+                dropSocket(ws);
+                ws = undefined;
+                if ((await run(["stream", "disable"]))?.code !== 0 || closed)
+                    return false;
+                if ((await run(["stream", "enable", "--port", String(port)]))?.code !== 0 || closed)
+                    return false;
+                const fresh = await reconnect();
+                if (fresh === undefined)
+                    return false;
+                if (closed) {
+                    dropSocket(fresh);
+                    return false;
+                }
+                ws = fresh;
+                attachStream(fresh);
+                frameSeen = false;
+                return true;
+            };
+            const armNudge = () => {
+                cancelNudge?.();
+                cancelNudge = schedule(() => {
+                    cancelNudge = undefined;
+                    if (!closed && !frameSeen && !running)
+                        void nudge();
+                }, firstFrameTimeoutMs);
+            };
+            const nudge = async () => {
+                running = true;
+                retargeting = true;
+                const ok = await restartStream();
+                running = false;
+                retargeting = false;
+                if (closed)
+                    return;
+                if (!ok) {
+                    finish("nudge_failed");
+                    return;
+                }
+                flushQueued();
+                if (desired !== undefined)
+                    void retargetLoop();
+            };
+            const attemptRetarget = async (target, reason) => {
+                const tab = await resolveTab(target);
+                if (tab === undefined || closed)
+                    return false;
+                if ((await run(["tab", tab.tabId]))?.code !== 0 || closed)
+                    return false;
+                if (!(await restartStream()))
+                    return false;
+                current = target;
+                latest.delete("frame");
+                armNudge();
+                const message = { type: "retarget", data: { tab: tab.tabId, url: tab.url, reason } };
+                for (const subscriber of [...subscribers])
+                    subscriber(message);
+                const fresh = pages.get(target)?.url ?? "";
+                if (fresh !== "") {
+                    const urlMessage = { type: "url", data: { url: fresh } };
+                    latest.set("url", urlMessage);
+                    if (fresh !== tab.url)
+                        for (const subscriber of [...subscribers])
+                            subscriber(urlMessage);
+                }
+                return true;
+            };
+            const flushQueued = () => {
+                for (const batch of queued.splice(0)) {
+                    if (ws === undefined || ws.readyState !== WS_OPEN) {
+                        batch.done({ ok: false, reason: "upstream_unavailable" });
+                        continue;
+                    }
+                    for (const event of batch.events)
+                        ws.send(JSON.stringify(event));
+                    batch.done({ ok: true, accepted: batch.events.length });
+                }
+            };
+            const retargetLoop = async () => {
+                running = true;
+                retargeting = true;
+                cancelNudge?.();
+                cancelNudge = undefined;
+                while (desired !== undefined && !closed) {
+                    const { target, reason } = desired;
+                    desired = undefined;
+                    if (target === current || !pages.has(target))
+                        continue;
+                    let ok = false;
+                    for (let attempt = 0; attempt < RETARGET_ATTEMPTS && !ok && !closed; attempt++) {
+                        ok = await attemptRetarget(target, reason);
+                    }
+                    if (closed)
+                        break;
+                    if (!ok) {
+                        finish("retarget_failed");
+                        break;
+                    }
+                }
+                running = false;
+                retargeting = false;
+                if (!closed)
+                    flushQueued();
+            };
+            const want = (target, reason) => {
+                desired = { target, reason };
+                if (!running)
+                    void retargetLoop();
+            };
+            const publishUrl = (url) => {
+                const known = latest.get("url")?.data;
+                if (url === "" || known?.url === url)
+                    return;
+                const message = { type: "url", data: { url } };
+                latest.set("url", message);
+                for (const subscriber of [...subscribers])
+                    subscriber(message);
+            };
+            const onTarget = (method, params) => {
+                if (closed)
+                    return;
+                if (method === "Target.targetDestroyed") {
+                    const id = params.targetId;
+                    if (typeof id !== "string")
+                        return;
+                    const gone = pages.get(id);
+                    pages.delete(id);
+                    const session = targetSessions.get(id);
+                    targetSessions.delete(id);
+                    if (session !== undefined) {
+                        sessionTargets.delete(session);
+                        endDialogsWhere((open) => open.sessionId === session, "closed_by_page");
+                    }
+                    if (desired?.target === id)
+                        desired = undefined;
+                    if (gone !== undefined && id === current) {
+                        const back = gone.opener !== undefined && pages.has(gone.opener) ? gone.opener : [...pages.keys()].at(-1);
+                        if (back !== undefined)
+                            want(back, "tab_closed");
+                    }
+                    return;
+                }
+                const info = params.targetInfo;
+                if (!isPlainObject(info) || info.type !== "page" || typeof info.targetId !== "string")
+                    return;
+                const id = info.targetId;
+                const url = typeof info.url === "string" ? info.url : "";
+                const opener = typeof info.openerId === "string" ? info.openerId : undefined;
+                const isNew = !pages.has(id);
+                pages.set(id, { opener: opener ?? pages.get(id)?.opener, url });
+                if (current === undefined && /^https?:/.test(url))
+                    current = id;
+                if (id === current)
+                    publishUrl(url);
+                if (isNew && opener !== undefined)
+                    want(id, "popup_opened");
+            };
+            if (cdp !== undefined) {
+                cdp.onmessage = (event) => {
+                    if (typeof event.data !== "string")
+                        return;
+                    try {
+                        const parsed = JSON.parse(event.data);
+                        if (!isPlainObject(parsed))
+                            return;
+                        if (typeof parsed.id === "number") {
+                            const done = cdpPending.get(parsed.id);
+                            if (done === undefined)
+                                return;
+                            cdpPending.delete(parsed.id);
+                            const error = isPlainObject(parsed.error) ? parsed.error : undefined;
+                            done(error === undefined ? { result: parsed.result } : { error: { code: typeof error.code === "number" ? error.code : undefined } });
+                            return;
+                        }
+                        if (typeof parsed.method !== "string" || !isPlainObject(parsed.params))
+                            return;
+                        const sessionId = typeof parsed.sessionId === "string" ? parsed.sessionId : undefined;
+                        switch (parsed.method) {
+                            case "Target.targetCreated":
+                            case "Target.targetInfoChanged":
+                            case "Target.targetDestroyed":
+                                onTarget(parsed.method, parsed.params);
+                                break;
+                            case "Target.attachedToTarget":
+                                if (!closed)
+                                    onAttached(parsed.params);
+                                break;
+                            case "Target.detachedFromTarget":
+                                if (!closed)
+                                    onDetached(parsed.params);
+                                break;
+                            case "Page.javascriptDialogOpening":
+                                if (!closed && sessionId !== undefined)
+                                    onDialogOpening(sessionId, parsed.params);
+                                break;
+                            case "Page.javascriptDialogClosed":
+                                if (!closed && sessionId !== undefined)
+                                    onDialogClosed(sessionId, parsed.params);
+                                break;
+                        }
+                    }
+                    catch {
+                        return;
+                    }
+                };
+                const watcher = cdp;
+                watcher.onclose = () => {
+                    watcher.onmessage = watcher.onclose = null;
+                    if (cdp !== watcher)
+                        return;
+                    cdp = undefined;
+                    for (const done of [...cdpPending.values()])
+                        done(undefined);
+                    cdpPending.clear();
+                    targetSessions.clear();
+                    sessionTargets.clear();
+                    endDialogsWhere(() => true, "closed_by_page");
+                };
+                cdpSend("Target.setDiscoverTargets", { discover: true });
+                cdpSend("Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: true, flatten: true });
+            }
+            armNudge();
+            const waitFor = async (ready) => {
+                for (let i = 0; i < REOPEN_WAIT_TRIES && !closed; i++) {
+                    if (ready())
+                        return true;
+                    await pause();
+                }
+                return !closed && ready();
+            };
+            const reopenTab = async () => {
+                if (closed)
+                    return { ok: false, reason: "closed" };
+                if (cdp === undefined || cdp.readyState !== WS_OPEN)
+                    return { ok: false, reason: "upstream_unavailable" };
+                const old = current;
+                const url = old === undefined ? "" : (pages.get(old)?.url ?? "");
+                if (old === undefined || url === "")
+                    return { ok: false, reason: "no_tab" };
+                const at = now();
+                if (reopening || (lastReopenAt !== undefined && at >= lastReopenAt && at - lastReopenAt < reopenMinIntervalMs)) {
+                    return { ok: false, reason: "rate_limited" };
+                }
+                reopening = true;
+                lastReopenAt = at;
+                try {
+                    const created = await cdpCall("Target.createTarget", { url });
+                    const fresh = isPlainObject(created?.result) ? created.result.targetId : undefined;
+                    if (typeof fresh !== "string")
+                        return { ok: false, reason: closed ? "closed" : "failed" };
+                    const closeTarget = (targetId) => void cdpSend("Target.closeTarget", { targetId });
+                    if (!(await waitFor(() => pages.has(fresh)))) {
+                        closeTarget(fresh);
+                        return { ok: false, reason: closed ? "closed" : "failed" };
+                    }
+                    want(fresh, "reopened");
+                    const streaming = await waitFor(() => current === fresh && !retargeting && frameSeen);
+                    if (closed)
+                        return { ok: false, reason: "closed" };
+                    if (!streaming) {
+                        closeTarget(fresh);
+                        return { ok: false, reason: "failed" };
+                    }
+                    closeTarget(old);
+                    return { ok: true };
+                }
+                finally {
+                    reopening = false;
+                }
+            };
+            const reject = (reason) => ({ ok: false, reason });
+            return {
+                subscribe(subscriber) {
+                    if (closed) {
+                        subscriber({ type: "closed", data: { reason: "closed" } });
+                        return () => { };
+                    }
+                    for (const type of REPLAYED) {
+                        if (type === "frame") {
+                            for (const { dialog } of openDialogs.values())
+                                subscriber({ type: "dialog", data: dialog });
+                        }
+                        const message = latest.get(type);
+                        if (message !== undefined)
+                            subscriber(message);
+                    }
+                    subscribers.add(subscriber);
+                    return () => {
+                        subscribers.delete(subscriber);
+                    };
+                },
+                async sendInput(events) {
+                    if (closed)
+                        return reject("closed");
+                    if (!Array.isArray(events))
+                        return reject("not_array");
+                    if (events.length > maxBatch)
+                        return reject("batch_too_large");
+                    if (!events.every(validEvent))
+                        return reject("invalid_event");
+                    const at = now();
+                    if (at - windowStart >= 1000 || at < windowStart) {
+                        windowStart = at;
+                        windowCount = 0;
+                    }
+                    if (windowCount + events.length > maxPerSecond)
+                        return reject("rate_limited");
+                    if (retargeting) {
+                        if (queued.length >= MAX_QUEUED_BATCHES)
+                            return reject("upstream_unavailable");
+                        windowCount += events.length;
+                        return new Promise((done) => queued.push({ events, done }));
+                    }
+                    if (ws === undefined || ws.readyState !== WS_OPEN)
+                        return reject("upstream_unavailable");
+                    windowCount += events.length;
+                    for (const event of events)
+                        ws.send(JSON.stringify(event));
+                    return { ok: true, accepted: events.length };
+                },
+                async answerDialog(answer) {
+                    if (closed)
+                        return { ok: false, reason: "closed" };
+                    if (!isPlainObject(answer) ||
+                        typeof answer.id !== "string" ||
+                        answer.id.length === 0 ||
+                        answer.id.length > MAX_DIALOG_ID ||
+                        typeof answer.accept !== "boolean" ||
+                        (answer.promptText !== undefined &&
+                            (typeof answer.promptText !== "string" || answer.promptText.length > MAX_DIALOG_TEXT))) {
+                        return { ok: false, reason: "invalid" };
+                    }
+                    const open = openDialogs.get(answer.id);
+                    if (open === undefined || open.answered)
+                        return { ok: false, reason: "no_dialog" };
+                    if (!open.dialog.answerable)
+                        return { ok: false, reason: "not_answerable" };
+                    open.answered = true;
+                    const params = { accept: answer.accept };
+                    if (answer.accept && open.dialog.kind === "prompt") {
+                        params.promptText = answer.promptText ?? open.dialog.defaultPrompt;
+                    }
+                    const reply = await cdpCall("Page.handleJavaScriptDialog", params, open.sessionId);
+                    if (closed)
+                        return { ok: false, reason: "closed" };
+                    if (reply?.error?.code === CDP_NO_DIALOG)
+                        return { ok: false, reason: "no_dialog" };
+                    if (reply === undefined || reply.error !== undefined) {
+                        open.answered = false;
+                        return { ok: false, reason: "closed" };
+                    }
+                    return { ok: true };
+                },
+                reopenTab,
+                clearFrame() {
+                    latest.delete("frame");
+                },
+                async close() {
+                    finish("closed");
+                },
+            };
+        },
+    };
+}