@poe-platform/safe-bash 0.1.695 → 0.1.697

package/dist/safe-playwright-cloudflare/browser-run-code-native.js

@@ -0,0 +1,180 @@
+import { PlaywrightResourceLimitError } from "@poe-platform/safe-bash/playwright";
+import { browserPageCDP } from "./browser-page-cdp.js";
+import { MAX_PAGE_STATE_BYTES, MAX_RUN_CODE_INIT_SCRIPTS, } from "./browser-run-code-state.js";
+// Pinned @cloudflare/playwright 1.3.6 server/page.js InitScript wraps each source.
+// Transferred sources already have the guest wrapper; host registration adds one.
+const NATIVE_INIT_SCRIPT_WRAPPER_BYTES = new TextEncoder().encode("(() => {\n      \n    })();").byteLength;
+function connection(browser) {
+    return browser._connection;
+}
+/** CDP has no context-disposed event for another connection. Call only after
+ * Target.getBrowserContexts confirms this owned context no longer exists. */
+export async function forgetClosedRunCodeContext(browser, context, contextId) {
+    if (!browser.contexts().includes(context))
+        return;
+    const nativeBrowser = connection(browser).toImpl(browser);
+    const nativeContext = connection(browser).toImpl(context);
+    if (nativeBrowser._contexts.get(contextId) !== nativeContext)
+        throw new Error("Native Playwright context identity changed");
+    const closed = context.waitForEvent("close", { timeout: 0 });
+    nativeBrowser._contexts.delete(contextId);
+    nativeContext.initScripts = [];
+    nativeContext._browserClosed();
+    await closed;
+}
+/** Native defaults live on the client, independently of browser context options. */
+function timeoutSettings(value) {
+    return value._timeoutSettings;
+}
+export function captureRunCodeTimeouts(value) {
+    const settings = timeoutSettings(value);
+    return {
+        action: settings.defaultTimeout() ?? null,
+        navigation: settings.defaultNavigationTimeout() ?? null,
+    };
+}
+export function restoreRunCodeTimeouts(value, timeouts) {
+    // The pinned native setters accept undefined to restore inheritance.
+    const settings = timeoutSettings(value);
+    settings.setDefaultTimeout(timeouts.action ?? undefined);
+    settings.setDefaultNavigationTimeout(timeouts.navigation ?? undefined);
+}
+/** Pinned @cloudflare/playwright 1.3.6 reconnects incognito pages as default. */
+export function adoptRunCodeContext(browser, metadata) {
+    const native = connection(browser).toImpl(browser);
+    if (!native._defaultContext || !(native._contexts instanceof Map))
+        throw new Error("Unsupported native Playwright context implementation");
+    const context = native._defaultContext;
+    context._browserContextId = metadata.contextId;
+    context._options = metadata.contextOptions;
+    native._contexts.set(metadata.contextId, context);
+    const client = browser.contexts()[0];
+    if (!client)
+        throw new Error("Native Playwright context missing");
+    client._options = metadata.contextOptions;
+    restoreRunCodeTimeouts(client, metadata.state.contextTimeouts);
+}
+export function captureRunCodePageState(browser, page) {
+    const native = connection(browser).toImpl(page);
+    return {
+        targetId: native.delegate._targetId,
+        viewport: page.viewportSize(),
+        size: native.emulatedSize() ?? null,
+        media: native._emulatedMedia,
+        timeouts: captureRunCodeTimeouts(page),
+        // Existing registrations belong to the retained connection. Reinstalling
+        // them in the guest would execute each script twice on navigation.
+        initScripts: [],
+    };
+}
+/** Only scripts newly registered on the guest connection need transferring. */
+export function captureRunCodeState(browser, context) {
+    if (!browser.contexts().includes(context))
+        return {
+            // Closed contexts have no native mapping and will not be restored.
+            context: { headers: [], offline: false, geolocation: null },
+            pages: [],
+            contextInitScripts: [],
+            contextTimeouts: captureRunCodeTimeouts(context),
+        };
+    const native = connection(browser).toImpl(context);
+    return {
+        context: captureRunCodeContextState(browser, context),
+        pages: context.pages().map((page) => ({
+            ...captureRunCodePageState(browser, page),
+            initScripts: connection(browser)
+                .toImpl(page)
+                .initScripts.map((script) => script.source),
+        })),
+        contextTimeouts: captureRunCodeTimeouts(context),
+        contextInitScripts: native.initScripts
+            .filter((script) => script !== native.bindingsInitScript)
+            .map((script) => script.source),
+    };
+}
+export function captureRunCodeContextState(browser, context) {
+    const options = connection(browser).toImpl(context)._options;
+    return {
+        headers: options.extraHTTPHeaders?.map(({ name, value }) => ({ name, value })) ??
+            [],
+        offline: options.offline ?? false,
+        geolocation: options.geolocation ?? null,
+    };
+}
+/** Replace configured registrations with their captured dynamic equivalents. */
+export async function replaceRunCodeContextInitScripts(browser, context, sources) {
+    const native = connection(browser).toImpl(context);
+    await native.removeInitScripts(native.initScripts.filter(script => script !== native.bindingsInitScript));
+    for (const source of sources)
+        await context.addInitScript(source);
+}
+/** Admit the entire batch against live native registrations before transferring it.
+ * Closed pages/contexts release capacity naturally; no lifetime counter is kept. */
+export function validateRunCodeInitScripts(browser, context, state) {
+    let count = 0;
+    let bytes = 0;
+    const encoder = new TextEncoder();
+    const include = (source, wrapperBytes = 0) => {
+        count++;
+        bytes += encoder.encode(source).byteLength + wrapperBytes;
+        if (count > MAX_RUN_CODE_INIT_SCRIPTS || bytes > MAX_PAGE_STATE_BYTES)
+            throw new PlaywrightResourceLimitError("Run-code retained init script limit exceeded");
+    };
+    const native = connection(browser).toImpl(context);
+    for (const script of native.initScripts)
+        if (script !== native.bindingsInitScript)
+            include(script.source);
+    for (const source of state.contextInitScripts)
+        include(source, NATIVE_INIT_SCRIPT_WRAPPER_BYTES);
+    for (const page of context.pages())
+        includePageInitScripts(browser, page, state.pages, include);
+}
+function includePageInitScripts(browser, page, pages, include) {
+    if (page.isClosed())
+        return;
+    const retained = connection(browser).toImpl(page);
+    for (const script of retained.initScripts)
+        include(script.source);
+    const incoming = pages.find((value) => value.targetId === retained.delegate._targetId);
+    if (!incoming)
+        throw new Error("Run-code page state is unavailable");
+    for (const source of incoming.initScripts)
+        include(source, NATIVE_INIT_SCRIPT_WRAPPER_BYTES);
+}
+/** Reconnecting CDP clients reset emulation on detach. Reapply the native state,
+ * including user changes, and invalidate Chromium's now-stale metrics cache. */
+export async function restoreRunCodePageState(browser, page, state) {
+    const native = connection(browser).toImpl(page);
+    restoreRunCodeTimeouts(page, state.timeouts);
+    page._viewportSize = state.viewport;
+    native._setEmulatedSize(state.size);
+    native._emulatedMedia = state.media;
+    native.delegate._mainFrameSession._metricsOverride = undefined;
+    const cdp = await browserPageCDP(page);
+    await Promise.all([
+        ...state.initScripts.map((source) => page.addInitScript(source)),
+        native.delegate.updateEmulatedViewportSize(true),
+        native.delegate.updateEmulateMedia(),
+        native.delegate.updateUserAgent(),
+    ]);
+    const metrics = native.delegate._mainFrameSession._metricsOverride;
+    if (metrics) {
+        // Another CDP client's detach clears renderer emulation, but Chromium
+        // retains this session's last metrics and ignores an identical override.
+        // Clear that protocol cache before restoring repeated guest executions.
+        await cdp.send("Emulation.clearDeviceMetricsOverride");
+        await cdp.send("Emulation.setDeviceMetricsOverride", metrics);
+    }
+}
+export function runCodeContextOptions(browser, page) {
+    const options = connection(browser).toImpl(page.context())._options;
+    const { storageState: ignoredStorageState, ...result } = options;
+    return result;
+}
+/** Pinned native target identity avoids page CDP detach resetting touch. */
+export function runCodePageTarget(browser, page) {
+    const targetId = connection(browser).toImpl(page).delegate._targetId;
+    if (typeof targetId !== "string" || !targetId)
+        throw new Error("Unsupported native Playwright page implementation");
+    return targetId;
+}

package/dist/safe-playwright-cloudflare/browser-run-code-relay.js

@@ -0,0 +1,149 @@
+import { RpcTarget } from "cloudflare:workers";
+import { waitForBrowserSocketClose } from "./browser-private-transport.js";
+import { createRunCodeFrameBudget, } from "./browser-run-code-budget.js";
+import { BROWSER_RUN_CODE_URL, } from "./browser-run-code-contract.js";
+import { closeBrowserSocket, registerBrowserSocketClose, } from "./browser-socket-closure.js";
+export function createRunCodeRelay(options) {
+    const charge = createRunCodeFrameBudget();
+    let revoked = false;
+    let opening = false;
+    let socket;
+    let receiver;
+    let incoming = Promise.resolve();
+    const admitted = Promise.withResolvers();
+    let closing;
+    const check = () => {
+        options.signal.throwIfAborted();
+        if (revoked)
+            throw new Error("Run-code browser access revoked");
+    };
+    async function closeSocket() {
+        if (!socket)
+            return;
+        const failures = [];
+        try {
+            closeBrowserSocket(socket);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        try {
+            await waitForBrowserSocketClose(socket);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        if (failures.length)
+            throw new AggregateError(failures, "Run-code socket cleanup failed");
+    }
+    async function closeReceiver() {
+        if (!receiver)
+            return;
+        const retained = receiver;
+        receiver = undefined;
+        const failures = [];
+        try {
+            await retained.close();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        try {
+            retained[Symbol.dispose]();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        if (failures.length)
+            throw new AggregateError(failures, "Run-code receiver cleanup failed");
+    }
+    function assertCleanup(outcomes) {
+        const failures = outcomes
+            .filter((outcome) => outcome.status === "rejected")
+            .map((outcome) => outcome.reason);
+        if (failures.length)
+            throw new AggregateError(failures, "Run-code transport cleanup failed");
+    }
+    const close = () => {
+        if (closing)
+            return closing;
+        revoked = true;
+        closing = (async () => {
+            if (opening)
+                await admitted.promise;
+            assertCleanup(await Promise.allSettled([closeSocket(), closeReceiver()]));
+        })();
+        void closing.catch(() => { });
+        return closing;
+    };
+    const fail = (error) => {
+        if (revoked)
+            return;
+        void close().catch(options.fail);
+        options.fail(error);
+    };
+    class Session extends RpcTarget {
+        send(message) {
+            try {
+                check();
+                options.creations.command(charge(message));
+                socket.send(message);
+            }
+            catch (error) {
+                fail(error);
+                throw error;
+            }
+        }
+        close() {
+            return close();
+        }
+    }
+    class Relay extends RpcTarget {
+        async open(url, callback) {
+            check();
+            if (opening || url !== BROWSER_RUN_CODE_URL)
+                throw new Error("Run-code may connect only to its owned browser");
+            opening = true;
+            try {
+                receiver = callback.dup();
+                socket = await options.connectSocket(options.signal);
+                registerBrowserSocketClose(socket);
+                check();
+                socket.accept();
+                socket.addEventListener("message", (event) => {
+                    try {
+                        check();
+                        options.creations.reply(charge(event.data));
+                        const message = event.data;
+                        incoming = incoming.then(async () => {
+                            if (revoked)
+                                return;
+                            check();
+                            await receiver.frame(message);
+                        });
+                        void incoming.catch(fail);
+                    }
+                    catch (error) {
+                        fail(error);
+                    }
+                });
+                socket.addEventListener("close", () => {
+                    if (!revoked)
+                        fail(new Error("Run-code CDP transport closed"));
+                });
+                socket.addEventListener("error", () => {
+                    fail(new Error("Run-code CDP transport failed"));
+                });
+                return new Session();
+            }
+            catch (error) {
+                fail(error);
+                throw error;
+            }
+            finally {
+                admitted.resolve();
+            }
+        }
+    }
+    return { capability: new Relay(), close, opened: () => opening };
+}

package/dist/safe-playwright-cloudflare/browser-run-code-state.js

@@ -0,0 +1,102 @@
+import { isRunCodeContextState, } from "./browser-run-code-context-state.js";
+export const MAX_PAGE_STATE_BYTES = 64 * 1024;
+export const MAX_RUN_CODE_INIT_SCRIPTS = 256;
+const mediaValues = {
+    media: ["screen", "print", "no-override"],
+    colorScheme: ["dark", "light", "no-preference", "no-override"],
+    reducedMotion: ["reduce", "no-preference", "no-override"],
+    forcedColors: ["active", "none", "no-override"],
+    contrast: ["more", "no-preference", "no-override"],
+};
+// type-erasure-boundary -- JSON completion data comes from the untrusted Worker guest.
+function allowedObject(value, keys) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).every((key) => keys.includes(key)));
+}
+function dimensions(value) {
+    if (!allowedObject(value, ["width", "height"]))
+        return false;
+    return [value.width, value.height].every((dimension) => typeof dimension === "number" &&
+        Number.isSafeInteger(dimension) &&
+        dimension >= 1 &&
+        dimension <= 32768);
+}
+function media(value) {
+    if (!allowedObject(value, Object.keys(mediaValues)))
+        return false;
+    return Object.entries(value).every(([key, entry]) => typeof entry === "string" &&
+        mediaValues[key].includes(entry));
+}
+function emulatedSize(value) {
+    return (value === null ||
+        (allowedObject(value, ["viewport", "screen"]) &&
+            dimensions(value.viewport) &&
+            dimensions(value.screen)));
+}
+function scripts(value) {
+    return (Array.isArray(value) &&
+        value.length <= MAX_RUN_CODE_INIT_SCRIPTS &&
+        value.every((source) => typeof source === "string"));
+}
+function timeouts(value) {
+    if (!allowedObject(value, ["action", "navigation"]))
+        return false;
+    return [value.action, value.navigation].every((timeout) => timeout === null ||
+        (typeof timeout === "number" && Number.isFinite(timeout) && timeout >= 0));
+}
+function pageState(value) {
+    if (!allowedObject(value, [
+        "targetId",
+        "viewport",
+        "size",
+        "media",
+        "initScripts",
+        "timeouts",
+    ]))
+        return false;
+    const id = value.targetId;
+    return (typeof id === "string" &&
+        id.length > 0 &&
+        id.length <= 256 &&
+        (value.viewport === null || dimensions(value.viewport)) &&
+        emulatedSize(value.size) &&
+        media(value.media) &&
+        timeouts(value.timeouts) &&
+        scripts(value.initScripts));
+}
+/** Fixed schema and byte cap bound the guest's separate native state response. */
+export function parseRunCodeState(json) {
+    if (typeof json !== "string" ||
+        new TextEncoder().encode(json).byteLength > MAX_PAGE_STATE_BYTES)
+        throw new Error("Run-code page state byte limit exceeded");
+    const value = JSON.parse(json);
+    if (!allowedObject(value, [
+        "pages",
+        "contextInitScripts",
+        "contextTimeouts",
+        "context",
+    ]) ||
+        !isRunCodeContextState(value.context) ||
+        !Array.isArray(value.pages) ||
+        value.pages.length > 64 ||
+        !value.pages.every(pageState) ||
+        !scripts(value.contextInitScripts) ||
+        !timeouts(value.contextTimeouts) ||
+        value.contextInitScripts.length +
+            value.pages.reduce((count, page) => count + page.initScripts.length, 0) >
+            MAX_RUN_CODE_INIT_SCRIPTS)
+        throw new Error("Invalid run-code page state");
+    return {
+        context: value.context,
+        pages: value.pages,
+        contextInitScripts: value.contextInitScripts,
+        contextTimeouts: value.contextTimeouts,
+    };
+}
+export function serializeRunCodeState(state) {
+    const json = JSON.stringify(state);
+    parseRunCodeState(json);
+    return json;
+}

package/dist/safe-playwright-cloudflare/browser-run-code.js

@@ -0,0 +1,251 @@
+import { PlaywrightResourceLimitError } from "@poe-platform/safe-bash/playwright";
+import { browserPageCDP } from "./browser-page-cdp.js";
+import { createRunCodeCreationBudget, MAX_RUN_CODE_CONTEXTS, MAX_RUN_CODE_TARGETS, } from "./browser-run-code-budget.js";
+import { restoreRunCodeContextState } from "./browser-run-code-context-state.js";
+import { captureRunCodeContextState, captureRunCodePageState, captureRunCodeTimeouts, forgetClosedRunCodeContext, restoreRunCodePageState, restoreRunCodeTimeouts, runCodeContextOptions, validateRunCodeInitScripts, } from "./browser-run-code-native.js";
+import { createRunCodeRelay } from "./browser-run-code-relay.js";
+import { parseRunCodeState } from "./browser-run-code-state.js";
+const activeOwners = new Set();
+const MAX_SOURCE_BYTES = 1024 * 1024;
+const MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
+class RunCodeUserError extends Error {
+}
+function validate(input) {
+    input.signal.throwIfAborted();
+    if (new TextEncoder().encode(input.source).byteLength > MAX_SOURCE_BYTES)
+        throw new PlaywrightResourceLimitError("Run-code source limit exceeded");
+    for (const [value, maximum] of [
+        [input.timeoutMs, 30_000],
+        [input.maxOutputBytes, MAX_OUTPUT_BYTES],
+        [input.maxPages, 64],
+    ]) {
+        if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+            throw new PlaywrightResourceLimitError("Invalid run-code limits");
+    }
+}
+async function identify(options, input) {
+    const cdp = await browserPageCDP(input.page);
+    const { targetInfo } = await cdp.send("Target.getTargetInfo");
+    if (!targetInfo.browserContextId)
+        throw new Error("Run-code requires an owned private context");
+    return {
+        targetId: targetInfo.targetId,
+        contextId: targetInfo.browserContextId,
+        contextOptions: runCodeContextOptions(options.browser, input.page),
+        state: {
+            context: captureRunCodeContextState(options.browser, input.page.context()),
+            pages: input.page
+                .context()
+                .pages()
+                .map((page) => captureRunCodePageState(options.browser, page)),
+            contextInitScripts: [],
+            contextTimeouts: captureRunCodeTimeouts(input.page.context()),
+        },
+        maxOutputBytes: input.maxOutputBytes,
+    };
+}
+/** One execution per trusted owner. Browser identity never comes from source. */
+export function createBrowserRunCode(options) {
+    if (!options.ownerId || options.ownerId.length > 256)
+        throw new Error("Invalid browser owner");
+    return async (input) => {
+        validate(input);
+        if (activeOwners.has(options.ownerId))
+            throw new PlaywrightResourceLimitError("Run-code owner execution limit exceeded");
+        activeOwners.add(options.ownerId);
+        try {
+            return await execute(options, input);
+        }
+        finally {
+            activeOwners.delete(options.ownerId);
+        }
+    };
+}
+async function execute(options, input) {
+    const abort = new AbortController();
+    const failed = Promise.withResolvers();
+    // Observe rejection immediately while setup itself is still awaiting RPCs.
+    void failed.promise.catch(() => { });
+    let relay;
+    let retired;
+    const fail = (error) => {
+        if (abort.signal.aborted)
+            return;
+        abort.abort(error);
+        relay?.close();
+        retired = Promise.resolve().then(options.retire);
+        void retired.catch(() => { });
+        failed.reject(error);
+    };
+    const onAbort = () => fail(input.signal.reason);
+    input.signal.addEventListener("abort", onAbort, { once: true });
+    const deadline = AbortSignal.timeout(input.timeoutMs);
+    const onDeadline = () => fail(new PlaywrightResourceLimitError("Run-code deadline exceeded"));
+    deadline.addEventListener("abort", onDeadline, { once: true });
+    try {
+        input.signal.throwIfAborted();
+        return await Promise.race([
+            prepareAndRun(options, input, abort.signal, (value) => {
+                relay = value;
+            }, fail),
+            failed.promise,
+        ]);
+    }
+    catch (error) {
+        if (!(error instanceof RunCodeUserError))
+            fail(error);
+        throw error;
+    }
+    finally {
+        deadline.removeEventListener("abort", onDeadline);
+        input.signal.removeEventListener("abort", onAbort);
+        void relay?.close();
+        await retired;
+    }
+}
+async function prepareAndRun(options, input, signal, setRelay, fail) {
+    const metadata = await identify(options, input);
+    signal.throwIfAborted();
+    const observer = await options.browser.newBrowserCDPSession();
+    try {
+        const { targetInfos } = await observer.send("Target.getTargets");
+        const { browserContextIds } = await observer.send("Target.getBrowserContexts");
+        const foreign = targetInfos.filter((target) => target.type === "page" &&
+            target.browserContextId !== metadata.contextId);
+        if (foreign.some((target) => target.url !== "about:blank" ||
+            browserContextIds.includes(target.browserContextId ?? "")))
+            throw new Error("Run-code cannot reconnect another existing browser context");
+        await Promise.all(foreign.map((target) => observer.send("Target.closeTarget", { targetId: target.targetId })));
+        const targets = new Map(targetInfos
+            .filter((target) => target.browserContextId === metadata.contextId)
+            .map((target) => [target.targetId, target.type]));
+        if (targets.size > MAX_RUN_CODE_TARGETS ||
+            browserContextIds.length > MAX_RUN_CODE_CONTEXTS)
+            throw new PlaywrightResourceLimitError("Run-code browser resource limit exceeded");
+        const creations = createRunCodeCreationBudget({
+            maxPages: input.maxPages,
+            pages: [...targets]
+                .filter(([, type]) => type === "page")
+                .map(([id]) => id),
+            contexts: browserContextIds,
+        });
+        observer.on("Target.targetCreated", ({ targetInfo }) => {
+            try {
+                targets.set(targetInfo.targetId, targetInfo.type);
+                if (targets.size > MAX_RUN_CODE_TARGETS)
+                    throw new PlaywrightResourceLimitError("Run-code target limit exceeded");
+                if (targetInfo.type === "page")
+                    creations.pageCreated(targetInfo.targetId);
+            }
+            catch (error) {
+                fail(error);
+            }
+        });
+        observer.on("Target.targetDestroyed", ({ targetId }) => {
+            targets.delete(targetId);
+            creations.pageDestroyed(targetId);
+        });
+        await observer.send("Target.setDiscoverTargets", { discover: true });
+        signal.throwIfAborted();
+        const relay = createRunCodeRelay({
+            signal,
+            connectSocket: options.connectSocket,
+            creations,
+            fail,
+        });
+        setRelay(relay);
+        try {
+            return await runGuest(options, input, metadata, relay, signal);
+        }
+        catch (error) {
+            // Loader compilation can fail before any guest obtains browser access.
+            if (!relay.opened())
+                throw new RunCodeUserError(String(error));
+            throw error;
+        }
+        finally {
+            const closing = relay.close();
+            if (!signal.aborted) {
+                await closing;
+                signal.throwIfAborted();
+                await restoreState(options, input, metadata, observer, signal);
+            }
+        }
+    }
+    finally {
+        await observer.detach().catch(() => { });
+    }
+}
+async function runGuest(options, input, metadata, relay, signal) {
+    signal.throwIfAborted();
+    const worker = options.loader.load({
+        compatibilityDate: "2026-07-08",
+        compatibilityFlags: ["nodejs_compat"],
+        mainModule: "guest.js",
+        modules: {
+            "guest.js": options.guestSource,
+            "browser-user-code.js": `export default (${input.source}\n);`,
+        },
+        limits: { cpuMs: 1000, subRequests: 4096 },
+    });
+    const entry = worker.getEntrypoint();
+    const result = entry.run(relay.capability, metadata);
+    const dispose = () => {
+        result[Symbol.dispose]?.();
+        entry[Symbol.dispose]?.();
+    };
+    signal.addEventListener("abort", dispose, { once: true });
+    try {
+        const response = await result;
+        signal.throwIfAborted();
+        const state = parseRunCodeState(response.stateJson);
+        if (state.pages.length > input.maxPages)
+            throw new PlaywrightResourceLimitError("Run-code page state limit exceeded");
+        metadata.state = state;
+        if (!response.ok)
+            throw new RunCodeUserError(response.message.slice(0, 4096));
+        const json = response.json;
+        if (typeof json !== "string" ||
+            new TextEncoder().encode(json).byteLength > input.maxOutputBytes)
+            throw new PlaywrightResourceLimitError("Run-code output limit exceeded");
+        return JSON.parse(json);
+    }
+    finally {
+        signal.removeEventListener("abort", dispose);
+        dispose();
+    }
+}
+/** Restore after the provider confirms the guest connection has closed. */
+async function restoreState(options, input, metadata, observer, signal) {
+    const { browserContextIds } = await observer.send("Target.getBrowserContexts");
+    signal.throwIfAborted();
+    if (!browserContextIds.includes(metadata.contextId)) {
+        await forgetClosedRunCodeContext(options.browser, input.page.context(), metadata.contextId);
+        return;
+    }
+    const state = metadata.state;
+    if (!options.browser.contexts().includes(input.page.context()))
+        return;
+    validateRunCodeInitScripts(options.browser, input.page.context(), state);
+    await restoreRunCodeContextState(input.page.context(), state.context);
+    restoreRunCodeTimeouts(input.page.context(), state.contextTimeouts);
+    await Promise.all(state.contextInitScripts.map((source) => input.page.context().addInitScript(source)));
+    await Promise.all(input.page
+        .context()
+        .pages()
+        .map(async (page) => {
+        if (page.isClosed())
+            return;
+        const target = captureRunCodePageState(options.browser, page).targetId;
+        const pageState = state.pages.find((value) => value.targetId === target);
+        if (!pageState)
+            throw new Error("Run-code page state is unavailable");
+        await restoreRunCodePageState(options.browser, page, pageState);
+        const hasTouch = runCodeContextOptions(options.browser, page).hasTouch === true;
+        const cdp = await browserPageCDP(page);
+        await cdp.send("Emulation.setTouchEmulationEnabled", {
+            enabled: hasTouch,
+            maxTouchPoints: hasTouch ? 1 : undefined,
+        });
+    }));
+}