@poe-platform/safe-bash 0.1.696 → 0.1.697

package/dist/safe-playwright-cloudflare/browser-snapshot-json-injected.js

@@ -0,0 +1,80 @@
+/** Runs in the native utility world. O(nodes + bytes), bounded before CDP transfer. */
+export function serializeNativeSnapshot(injected, options) {
+    const MAX_SNAPSHOT_NODES = 20000;
+    const snapshot = injected._lastAriaSnapshotForQuery;
+    if (!snapshot)
+        throw new Error("Native browser snapshot is unavailable");
+    const encoder = new TextEncoder();
+    let bytes = 2;
+    let count = 0;
+    const account = (node) => {
+        // Reserve array/property separators while counting each shallow node once.
+        bytes += encoder.encode(JSON.stringify(node)).byteLength + 16;
+        if (bytes > options.maxBytes || ++count > MAX_SNAPSHOT_NODES)
+            throw new Error("Browser snapshot JSON limit exceeded");
+    };
+    const rectangle = (node) => {
+        const symbol = Object.getOwnPropertySymbols(node).find((key) => key.description === "element");
+        const element = symbol && node[symbol];
+        if (!element)
+            throw new Error("Native snapshot element is unavailable");
+        const { x, y, width, height } = element.getBoundingClientRect();
+        return {
+            x: Math.round(x),
+            y: Math.round(y),
+            width: Math.round(width),
+            height: Math.round(height),
+        };
+    };
+    const convertElement = (node) => {
+        const result = { role: node.role };
+        for (const key of [
+            "name",
+            "ref",
+            "checked",
+            "disabled",
+            "expanded",
+            "active",
+            "level",
+            "pressed",
+            "selected",
+        ]) {
+            if (node[key])
+                Object.assign(result, { [key]: node[key] });
+        }
+        if (node.ref && node.box.cursor === "pointer")
+            result.cursor = "pointer";
+        Object.assign(result, node.props);
+        if (options.boxes)
+            result.box = rectangle(node);
+        return result;
+    };
+    const convert = (node) => typeof node === "string"
+        ? { role: "text", text: node }
+        : convertElement(node);
+    const nodes = [];
+    if (snapshot.root.children.length > MAX_SNAPSHOT_NODES)
+        throw new Error("Browser snapshot JSON limit exceeded");
+    const pending = snapshot.root.children.map((node) => ({
+        node,
+        parent: nodes,
+    }));
+    const visit = (entry) => {
+        const result = convert(entry.node);
+        account(result);
+        entry.parent.push(result);
+        if (typeof entry.node === "string" || !entry.node.children.length)
+            return;
+        result.children = [];
+        if (pending.length + entry.node.children.length > MAX_SNAPSHOT_NODES)
+            throw new Error("Browser snapshot JSON limit exceeded");
+        for (const child of entry.node.children)
+            pending.push({ node: child, parent: result.children });
+    };
+    for (const entry of pending)
+        visit(entry);
+    const result = { nodes, iframeRefs: snapshot.iframeRefs };
+    if (encoder.encode(JSON.stringify(result)).byteLength > options.maxBytes)
+        throw new Error("Browser snapshot JSON limit exceeded");
+    return result;
+}

package/dist/safe-playwright-cloudflare/browser-snapshot-json.js

@@ -0,0 +1,89 @@
+import { serializeNativeSnapshot, } from "./browser-snapshot-json-injected.js";
+const MAX_SNAPSHOT_FRAMES = 128;
+// The pinned provider's native tree owns accessibility semantics and usable refs.
+// Newer engine-only fields (invalid/ariaHidden) are not invented here.
+// The controller retires the owning lease on rejection, including timeout,
+// before accepting another command; native in-flight capture cannot be reused.
+export const captureBrowserSnapshotJSON = async (page, options) => {
+    const native = page;
+    const signal = AbortSignal.any([
+        options.signal,
+        AbortSignal.timeout(options.timeoutMs),
+    ]);
+    signal.throwIfAborted();
+    let onAbort = () => { };
+    const aborted = new Promise((_, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+        return await Promise.race([
+            capture(native, { ...options, signal }),
+            aborted,
+        ]);
+    }
+    finally {
+        signal.removeEventListener("abort", onAbort);
+    }
+};
+async function capture(page, options) {
+    await page._snapshotForAI({ timeout: options.timeoutMs });
+    options.signal.throwIfAborted();
+    const root = page._connection.toImpl(page).mainFrame();
+    const encoder = new TextEncoder();
+    let remaining = options.maxBytes;
+    const forest = [];
+    const pending = [{ frame: root, target: forest }];
+    const visit = async (index) => {
+        options.signal.throwIfAborted();
+        const entry = pending[index];
+        if (!entry)
+            return;
+        if (index >= MAX_SNAPSHOT_FRAMES)
+            throw new Error("Browser snapshot frame limit exceeded");
+        const context = await entry.frame._utilityContext();
+        const injected = await context.injectedScript();
+        const result = await injected.evaluate(serializeNativeSnapshot, {
+            maxBytes: remaining,
+            boxes: options.boxes ?? false,
+        });
+        remaining -= encoder.encode(JSON.stringify(result.nodes)).byteLength;
+        entry.target.push(...result.nodes);
+        const byRef = indexNodes(result.nodes);
+        if (pending.length + result.iframeRefs.length > MAX_SNAPSHOT_FRAMES)
+            throw new Error("Browser snapshot frame limit exceeded");
+        const children = await Promise.all(result.iframeRefs.map(async (ref) => {
+            options.signal.throwIfAborted();
+            const target = byRef.get(ref);
+            if (!target)
+                return;
+            const resolved = await entry.frame.selectors.resolveFrameForSelector(`aria-ref=${ref} >> internal:control=enter-frame >> body`, { strict: true });
+            if (!resolved)
+                return;
+            target.children ??= [];
+            return { frame: resolved.frame, target: target.children };
+        }));
+        pending.push(...children.filter((child) => child !== undefined));
+        // Frame serialization shares one byte budget, so admit transfers in order.
+        await visit(index + 1);
+    };
+    await visit(0);
+    if (encoder.encode(JSON.stringify(forest)).byteLength > options.maxBytes)
+        throw new Error("Browser snapshot JSON limit exceeded");
+    return forest;
+}
+/** O(nodes), bounded by the renderer's byte and 20,000-node admission. */
+function indexNodes(nodes) {
+    const byRef = new Map();
+    const pending = [...nodes];
+    for (let index = 0; index < pending.length; index++) {
+        const node = pending[index];
+        if (!node)
+            continue;
+        if (node.ref)
+            byRef.set(node.ref, node);
+        if (node.children)
+            pending.push(...node.children);
+    }
+    return byRef;
+}

package/dist/safe-playwright-cloudflare/browser-socket-closure.js

@@ -0,0 +1,111 @@
+const closures = new WeakMap();
+function nativeClosedEOF(socket, event) {
+    if (event instanceof ErrorEvent &&
+        event.isTrusted &&
+        socket.readyState === WebSocket.CLOSED &&
+        event.error instanceof Error &&
+        event.error.message === "Network connection lost.")
+        return event.error;
+    return undefined;
+}
+export function beginBrowserOwnerShutdown(sockets) {
+    for (const socket of sockets) {
+        const closure = closures.get(socket);
+        if (closure)
+            closure.ownerClosing = true;
+    }
+}
+export function finalizeBrowserOwnerTermination(sockets, deleted) {
+    for (const socket of sockets)
+        closures.get(socket)?.finalizeOwnerTermination(deleted);
+}
+export function registerBrowserSocketClose(socket, alias = socket) {
+    let closure = closures.get(socket);
+    if (!closure) {
+        const completion = Promise.withResolvers();
+        let settled = false;
+        let eof;
+        let eofDuringClose = false;
+        const cleanup = () => {
+            socket.removeEventListener("close", closed);
+            socket.removeEventListener("error", failed);
+        };
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (error === undefined)
+                completion.resolve();
+            else
+                completion.reject(error);
+        };
+        const closed = (event) => {
+            cleanup();
+            finish(event.code === 1000 || event.code === 1005
+                ? undefined
+                : new Error(`Owned browser upstream closed: ${event.code} ${event.reason}`, { cause: eof }));
+        };
+        const failOperation = (error) => {
+            cleanup();
+            finish(error);
+        };
+        const failed = (event) => {
+            const nativeEOF = nativeClosedEOF(socket, event);
+            if (!nativeEOF) {
+                failOperation(new Error("Owned browser upstream socket failed before close confirmation"));
+                return;
+            }
+            eof = new Error("Owned browser upstream socket failed before close confirmation", { cause: nativeEOF });
+            eofDuringClose = closure.ownerClosing || closure.closing;
+            socket.removeEventListener("error", failed);
+            if (!eofDuringClose) {
+                failOperation(eof);
+                return;
+            }
+            if (closure.ownerTerminated !== undefined)
+                closure.finalizeOwnerTermination(closure.ownerTerminated);
+        };
+        closure = {
+            promise: completion.promise,
+            fail: failOperation,
+            ownerClosing: false,
+            closing: false,
+            finalizeOwnerTermination(deleted) {
+                closure.ownerTerminated = deleted;
+                if (!eof || !eofDuringClose || socket.readyState !== WebSocket.CLOSED)
+                    return;
+                cleanup();
+                finish(deleted ? undefined : eof);
+            },
+        };
+        closures.set(socket, closure);
+        socket.addEventListener("close", closed);
+        socket.addEventListener("error", failed);
+        if (socket.readyState === WebSocket.CLOSED) {
+            cleanup();
+            finish();
+        }
+        void completion.promise.catch(() => { });
+    }
+    closures.set(alias, closure);
+    return closure.promise;
+}
+export function waitForBrowserSocketClose(socket) {
+    return (closures.get(socket)?.promise ??
+        Promise.reject(new Error("Untracked browser socket has no upstream close confirmation")));
+}
+export function closeBrowserSocket(socket) {
+    try {
+        const closure = closures.get(socket);
+        if (closure)
+            closure.closing = true;
+        if (socket.readyState === WebSocket.CLOSED)
+            return;
+        socket.accept();
+        socket.close();
+    }
+    catch (error) {
+        closures.get(socket)?.fail(error);
+        throw error;
+    }
+}

package/dist/safe-playwright-cloudflare/browser-storage-control.js

@@ -0,0 +1,262 @@
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function identifier(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= 1024 &&
+        !value.includes("\0"));
+}
+function parseMessage(data, maxBytes) {
+    if (typeof data !== "string" ||
+        new TextEncoder().encode(data).length > maxBytes)
+        throw new Error("Owned storage control frame limit or type violation");
+    const value = JSON.parse(data);
+    if (!record(value))
+        throw new Error("Invalid owned storage control frame");
+    if (value["sessionId"] !== undefined && !identifier(value["sessionId"]))
+        throw new Error("Invalid owned storage control session");
+    if (value["id"] !== undefined)
+        return parseReply(value);
+    if (!identifier(value["method"]) ||
+        (value["params"] !== undefined && !record(value["params"])))
+        throw new Error("Invalid owned storage control event");
+    return {
+        method: value["method"],
+        params: value["params"],
+        sessionId: value["sessionId"],
+    };
+}
+function parseReply(value) {
+    if (typeof value["id"] !== "number" ||
+        !Number.isSafeInteger(value["id"]) ||
+        value["id"] <= 0)
+        throw new Error("Invalid owned storage control reply ID");
+    if (value["result"] !== undefined && !record(value["result"]))
+        throw new Error("Invalid owned storage control result");
+    const error = parseError(value["error"]);
+    if ((value["result"] === undefined) === (value["error"] === undefined))
+        throw new Error("Ambiguous owned storage control reply");
+    return {
+        method: "",
+        id: value["id"],
+        result: record(value["result"]) ? value["result"] : undefined,
+        error,
+        sessionId: identifier(value["sessionId"]) ? value["sessionId"] : undefined,
+    };
+}
+function parseError(value) {
+    if (value === undefined)
+        return;
+    if (!record(value) || typeof value["message"] !== "string")
+        throw new Error("Invalid owned storage control error");
+    return { message: value["message"] };
+}
+export function createBrowserStorageControl(options) {
+    const limits = {
+        maxMessageBytes: 16 * 1024 * 1024,
+        maxPendingCommands: 128,
+        maxPendingBytes: 4 * 1024 * 1024,
+        maxLateReplies: 128,
+        maxSubscriptions: 128,
+        commandTimeoutMs: 10000,
+        ...options.limits,
+    };
+    for (const [name, value] of Object.entries(limits)) {
+        if (!Number.isSafeInteger(value) ||
+            value <= 0 ||
+            (name.endsWith("TimeoutMs") && value > 2147483647))
+            throw new TypeError(`Invalid storage control limit: ${name}`);
+    }
+    const { socket } = options;
+    const pending = new Map();
+    const lateReplies = new Map();
+    const listeners = new Set();
+    const errors = [];
+    let pendingBytes = 0;
+    let sequence = 0;
+    let closed;
+    let closing;
+    function notifyDetached(reason) {
+        const event = {
+            method: "Inspector.detached",
+            params: { reason: reason.message },
+        };
+        for (const listener of [options.onEvent, ...listeners]) {
+            try {
+                listener?.(event);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+    }
+    function shutdown(reason) {
+        if (closed)
+            return;
+        closed = reason;
+        socket.removeEventListener("message", receive);
+        socket.removeEventListener("close", disconnected);
+        socket.removeEventListener("error", failed);
+        notifyDetached(reason);
+        for (const command of pending.values()) {
+            command.deadline.removeEventListener("abort", command.expire);
+            command.reject(reason);
+        }
+        pending.clear();
+        lateReplies.clear();
+        pendingBytes = 0;
+        listeners.clear();
+        try {
+            socket.close();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    function fail(error) {
+        if (closed)
+            return;
+        const reason = error instanceof Error ? error : new Error(String(error));
+        errors.push(reason);
+        shutdown(reason);
+    }
+    function disconnected(event) {
+        fail(new Error(`Owned storage control disconnected: ${event.code} ${event.reason}`));
+    }
+    function failed() {
+        fail(new Error("Owned storage control socket failed"));
+    }
+    function receive(event) {
+        try {
+            const message = parseMessage(event.data, limits.maxMessageBytes);
+            if (message.id !== undefined) {
+                settle(message);
+                return;
+            }
+            options.onEvent?.(message);
+            for (const listener of [...listeners]) {
+                if (closed)
+                    break;
+                listener(message);
+            }
+        }
+        catch (error) {
+            fail(error);
+        }
+    }
+    function settleLateReply(message) {
+        if (!lateReplies.has(message.id))
+            throw new Error("Unexpected owned storage control reply identity");
+        if (lateReplies.get(message.id) !== message.sessionId)
+            throw new Error("Unexpected owned storage control late reply session");
+        lateReplies.delete(message.id);
+    }
+    function settle(message) {
+        const command = pending.get(message.id);
+        if (!command) {
+            settleLateReply(message);
+            return;
+        }
+        if (command.sessionId !== message.sessionId)
+            throw new Error("Unexpected owned storage control reply identity");
+        pending.delete(message.id);
+        pendingBytes -= command.bytes;
+        command.deadline.removeEventListener("abort", command.expire);
+        if (message.error)
+            command.reject(new Error(message.error.message));
+        else
+            command.resolve(message.result);
+    }
+    socket.addEventListener("message", receive);
+    socket.addEventListener("close", disconnected);
+    socket.addEventListener("error", failed);
+    try {
+        socket.accept();
+    }
+    catch (error) {
+        fail(error);
+    }
+    function encodeCommand(method, params, sessionId) {
+        if (!identifier(method) ||
+            (sessionId !== undefined && !identifier(sessionId)))
+            throw new TypeError("Invalid owned storage control command identity");
+        if (params !== undefined && !record(params))
+            throw new TypeError("Invalid owned storage control command parameters");
+        if (sequence >= Number.MAX_SAFE_INTEGER)
+            throw new Error("Storage control ID capacity exceeded");
+        const id = ++sequence;
+        const data = JSON.stringify({ id, method, params, sessionId });
+        const bytes = new TextEncoder().encode(data).length;
+        return { id, data, bytes };
+    }
+    function admitCommand(bytes) {
+        if (bytes > limits.maxMessageBytes ||
+            pending.size >= limits.maxPendingCommands ||
+            bytes > limits.maxPendingBytes - pendingBytes)
+            throw new Error("Owned storage control pending or frame capacity exceeded");
+    }
+    function expireCommand(id, method) {
+        const command = pending.get(id);
+        if (!command)
+            return;
+        const reason = new Error(`Owned storage control command timed out: ${method}`);
+        if (method === "Target.createTarget" ||
+            lateReplies.size >= limits.maxLateReplies) {
+            fail(method === "Target.createTarget"
+                ? reason
+                : new Error("Owned storage control late reply capacity exceeded"));
+            return;
+        }
+        pending.delete(id);
+        pendingBytes -= command.bytes;
+        command.deadline.removeEventListener("abort", command.expire);
+        lateReplies.set(id, command.sessionId);
+        command.reject(reason);
+    }
+    return {
+        async send(method, params, sessionId) {
+            if (closed)
+                throw closed;
+            const { id, data, bytes } = encodeCommand(method, params, sessionId);
+            admitCommand(bytes);
+            const response = Promise.withResolvers();
+            const deadline = AbortSignal.timeout(limits.commandTimeoutMs);
+            const expire = () => expireCommand(id, method);
+            pending.set(id, {
+                ...response,
+                bytes,
+                sessionId,
+                deadline,
+                expire,
+            });
+            deadline.addEventListener("abort", expire, { once: true });
+            pendingBytes += bytes;
+            try {
+                socket.send(data);
+            }
+            catch (error) {
+                fail(error);
+            }
+            return await response.promise;
+        },
+        subscribe(listener) {
+            if (closed)
+                throw closed;
+            if (listeners.size >= limits.maxSubscriptions)
+                throw new Error("Owned storage control subscription capacity exceeded");
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        close() {
+            shutdown(new Error("Owned storage control closed"));
+            closing ??= Promise.resolve().then(() => {
+                if (errors.length)
+                    throw new AggregateError([...errors], "Owned storage control cleanup failed");
+            });
+            return closing;
+        },
+    };
+}

package/dist/safe-playwright-cloudflare/browser-trace.js

@@ -0,0 +1,143 @@
+import { lstat, open } from "node:fs/promises";
+import { PlaywrightResourceLimitError, } from "@poe-platform/safe-bash/playwright";
+const MAX_TRACE_FILES = 1024;
+const MAX_TRACE_PATH = 256;
+const pathsByTracing = new WeakMap();
+function safeName(name) {
+    return (name.length > 0 &&
+        name.length <= MAX_TRACE_PATH &&
+        name !== "." &&
+        name !== ".." &&
+        [...name].every((character) => "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._-@".includes(character)));
+}
+function nativeTracing(context) {
+    // @cloudflare/playwright 1.3.6 embeds its server inside the Worker. Only these
+    // pinned native internals own the trace paths; page data never supplies them.
+    const tracing = context.tracing;
+    if (!tracing?._connection?.toImpl)
+        throw new Error("Playwright provider does not support live trace capture");
+    const native = tracing._connection.toImpl(tracing);
+    if (!native?._fs?.syncAndGetError)
+        throw new Error("Native browser tracing unavailable");
+    return native;
+}
+function tracePaths(native) {
+    const state = native._state;
+    if (!state) {
+        const previous = pathsByTracing.get(native);
+        if (!previous)
+            throw new Error("Native browser trace has not started");
+        return previous;
+    }
+    const paths = {
+        tracesDir: state.tracesDir,
+        traceFile: state.traceFile,
+        networkFile: state.networkFile,
+        resourcesDir: state.resourcesDir,
+        traceSha1s: state.traceSha1s,
+        networkSha1s: state.networkSha1s,
+    };
+    const rootName = paths.tracesDir?.slice("/tmp/".length);
+    if (!paths.tracesDir?.startsWith("/tmp/playwright-artifacts-") ||
+        !safeName(rootName))
+        throw new Error("Invalid native browser trace directory");
+    for (const path of [paths.traceFile, paths.networkFile]) {
+        if (!path.startsWith(`${paths.tracesDir}/`) ||
+            !safeName(path.slice(paths.tracesDir.length + 1)))
+            throw new Error("Invalid native browser trace path");
+    }
+    if (paths.resourcesDir !== `${paths.tracesDir}/resources`)
+        throw new Error("Invalid native browser trace resources");
+    pathsByTracing.set(native, paths);
+    return paths;
+}
+async function readTraceFile(options) {
+    const { path, signal, remaining } = options;
+    signal.throwIfAborted();
+    const metadata = await lstat(path);
+    if (!metadata.isFile() || metadata.isSymbolicLink())
+        throw new Error("Native trace must be a regular file");
+    if (metadata.size > remaining)
+        throw new PlaywrightResourceLimitError("Browser trace byte limit exceeded");
+    const file = await open(path, "r");
+    try {
+        const current = await file.stat();
+        if (!current.isFile() ||
+            current.ino !== metadata.ino ||
+            current.dev !== metadata.dev)
+            throw new Error("Native trace file changed during capture");
+        const bytes = new Uint8Array(metadata.size);
+        let offset = 0;
+        while (offset < bytes.length) {
+            signal.throwIfAborted();
+            // biome-ignore lint/performance/noAwaitInLoops: Each short read advances the same bounded file cursor.
+            const { bytesRead } = await file.read(bytes, offset, bytes.length - offset, offset);
+            if (!bytesRead)
+                throw new Error("Native trace file truncated during capture");
+            offset += bytesRead;
+        }
+        return bytes;
+    }
+    finally {
+        await file.close();
+    }
+}
+function traceResources(paths) {
+    if (!(paths.traceSha1s instanceof Set) ||
+        !(paths.networkSha1s instanceof Set))
+        throw new Error("Native trace resource ownership unavailable");
+    if (paths.traceSha1s.size > MAX_TRACE_FILES ||
+        paths.networkSha1s.size > MAX_TRACE_FILES)
+        throw new PlaywrightResourceLimitError("Browser trace file count limit exceeded");
+    return [...paths.traceSha1s, ...paths.networkSha1s];
+}
+async function traceFiles(paths, signal) {
+    const root = await lstat(paths.tracesDir);
+    const resources = await lstat(paths.resourcesDir);
+    if (!root.isDirectory() || !resources.isDirectory())
+        throw new Error("Native trace paths must be directories");
+    const candidates = [paths.traceFile, paths.networkFile];
+    const seen = new Set();
+    // Keep references to the native recording's sets: stop replaces the state
+    // fields, while these sets still own its final resources, never sibling traces.
+    for (const name of traceResources(paths)) {
+        signal.throwIfAborted();
+        if (seen.has(name))
+            continue;
+        if (candidates.length >= MAX_TRACE_FILES)
+            throw new PlaywrightResourceLimitError("Browser trace file count limit exceeded");
+        if (!safeName(name))
+            throw new Error("Invalid native browser trace resource name");
+        seen.add(name);
+        candidates.push(`${paths.resourcesDir}/${name}`);
+    }
+    return candidates;
+}
+/** O(files + bytes), capped at 1024 files and the caller's aggregate byte limit.
+ * Native tracing can append after its flush; each read captures the admitted
+ * prefix, preserving future appends for the next command's flush. */
+export const captureBrowserTrace = async (context, options) => {
+    options.signal.throwIfAborted();
+    if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1)
+        throw new Error("Invalid browser trace byte limit");
+    const native = nativeTracing(context);
+    const paths = tracePaths(native);
+    const failure = await native._fs.syncAndGetError();
+    if (failure)
+        throw failure;
+    const candidates = await traceFiles(paths, options.signal);
+    const files = [];
+    let remaining = options.maxBytes;
+    for (const path of candidates) {
+        // biome-ignore lint/performance/noAwaitInLoops: Admission decrements the shared aggregate byte budget before the next file.
+        const bytes = await readTraceFile({
+            path,
+            signal: options.signal,
+            remaining,
+        });
+        remaining -= bytes.byteLength;
+        files.push({ path: path.slice(paths.tracesDir.length + 1), bytes });
+    }
+    options.signal.throwIfAborted();
+    return { files };
+};

package/dist/safe-playwright-cloudflare/index.d.ts

@@ -0,0 +1,2 @@
+export { createCloudflarePlaywrightAdapter } from './shell-playwright.js';
+export type { BrowserCodeRuntime } from './browser-code-executor.js';

package/dist/safe-playwright-cloudflare/index.js

@@ -0,0 +1 @@
+export { createCloudflarePlaywrightAdapter } from './shell-playwright.js';