@sylix/coworker 1.4.2 → 1.5.2

package/dist/services/browser/sandbox/quickjs-sandbox.js

@@ -0,0 +1,683 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _QuickJSSandbox_instances, _QuickJSSandbox_options, _QuickJSSandbox_anonymousPages, _QuickJSSandbox_pendingHostOperations, _QuickJSSandbox_transportInbox, _QuickJSSandbox_asyncError, _QuickJSSandbox_host, _QuickJSSandbox_hostBridge, _QuickJSSandbox_flushPromise, _QuickJSSandbox_disposed, _QuickJSSandbox_initialized, _QuickJSSandbox_routeConsole, _QuickJSSandbox_handleTransportSend, _QuickJSSandbox_drainAsyncOps, _QuickJSSandbox_flushTransportQueue, _QuickJSSandbox_getPage, _QuickJSSandbox_newPage, _QuickJSSandbox_closePage, _QuickJSSandbox_writeTempFile, _QuickJSSandbox_readTempFile, _QuickJSSandbox_cleanupAnonymousPages, _QuickJSSandbox_throwIfAsyncError, _QuickJSSandbox_assertAlive, _QuickJSSandbox_assertInitialized;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickJSSandbox = void 0;
+const promises_1 = require("node:fs/promises");
+const node_util_1 = __importDefault(require("node:util"));
+const temp_files_1 = require("../temp-files");
+const host_bridge_1 = require("./host-bridge");
+const quickjs_host_1 = require("./quickjs-host");
+const DEFAULT_MEMORY_LIMIT_BYTES = 512 * 1024 * 1024;
+const WAIT_FOR_OBJECT_ATTEMPTS = 1000;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+// Resolve sandbox-client.js: next to the running script (production), or in dist/ (development)
+function findBundlePath() {
+    const candidates = [
+        path.join(__dirname, "sandbox-client.js"),
+        path.join(__dirname, "..", "..", "..", "dist", "sandbox-client.js"),
+    ];
+    for (const p of candidates) {
+        if ((0, node_fs_1.existsSync)(p))
+            return p;
+    }
+    throw new Error(`Failed to find sandbox-client.js. Searched:\n${candidates.map((c) => `  - ${c}`).join("\n")}`);
+}
+const BUNDLE_PATH = findBundlePath();
+const TRANSPORT_RECEIVE_GLOBAL = "__transport_receive";
+let bundleCodePromise;
+function formatArgs(args) {
+    return args
+        .map((arg) => typeof arg === "string"
+        ? arg
+        : node_util_1.default.inspect(arg, {
+            colors: false,
+            depth: 6,
+            compact: 3,
+            breakLength: Infinity,
+        }))
+        .join(" ");
+}
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error));
+}
+function getSandboxClientBundleCode() {
+    bundleCodePromise ?? (bundleCodePromise = (0, promises_1.readFile)(BUNDLE_PATH, "utf8").catch((error) => {
+        bundleCodePromise = undefined;
+        const message = error instanceof Error ? error.message : "Sandbox client bundle could not be read";
+        throw new Error(`Failed to load sandbox client bundle at ${BUNDLE_PATH}: ${message}`);
+    }));
+    return bundleCodePromise;
+}
+function formatTimeoutDuration(timeoutMs) {
+    if (timeoutMs % 1000 === 0) {
+        return `${timeoutMs / 1000}s`;
+    }
+    return `${timeoutMs}ms`;
+}
+function createScriptTimeoutError(timeoutMs) {
+    const error = new Error(`Script timed out after ${formatTimeoutDuration(timeoutMs)} and was terminated.`);
+    error.name = "ScriptTimeoutError";
+    return error;
+}
+function createGuestScriptTimeoutErrorSource(timeoutMs) {
+    const message = JSON.stringify(createScriptTimeoutError(timeoutMs).message);
+    return `(() => {
+    const error = new Error(${message});
+    error.name = "ScriptTimeoutError";
+    return error;
+  })()`;
+}
+function wrapScriptWithWallClockTimeout(script, timeoutMs) {
+    if (timeoutMs === undefined) {
+        return script;
+    }
+    return `
+    (() => {
+      return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(${createGuestScriptTimeoutErrorSource(timeoutMs)});
+        }, ${timeoutMs});
+
+        Promise.resolve()
+          .then(() => (${script}))
+          .then(resolve, reject)
+          .finally(() => {
+            clearTimeout(timeoutId);
+          });
+      });
+    })()
+  `;
+}
+function requireString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new TypeError(`${label} must be a non-empty string`);
+    }
+    return value;
+}
+function toServerImpl(clientObject, label) {
+    const connection = clientObject
+        ._connection;
+    const toImpl = connection?.toImpl;
+    if (typeof toImpl !== "function") {
+        throw new Error(`${label} does not expose a server implementation`);
+    }
+    const impl = toImpl(clientObject);
+    if (!impl) {
+        throw new Error(`${label} could not be mapped to a server implementation`);
+    }
+    return impl;
+}
+function extractGuid(page) {
+    const guid = toServerImpl(page, "Playwright page").guid;
+    if (typeof guid !== "string" || guid.length === 0) {
+        throw new Error("Playwright page did not expose a guid");
+    }
+    return guid;
+}
+function decodeSandboxFilePayload(value, label) {
+    if (typeof value !== "object" || value === null) {
+        throw new TypeError(`${label} must be an object`);
+    }
+    const encoding = "encoding" in value ? value.encoding : undefined;
+    const data = "data" in value ? value.data : undefined;
+    if ((encoding !== "utf8" && encoding !== "base64") || typeof data !== "string") {
+        throw new TypeError(`${label} must include a valid encoding and string data`);
+    }
+    if (encoding === "utf8") {
+        return data;
+    }
+    return Buffer.from(data, "base64");
+}
+class QuickJSSandbox {
+    constructor(options) {
+        _QuickJSSandbox_instances.add(this);
+        _QuickJSSandbox_options.set(this, void 0);
+        _QuickJSSandbox_anonymousPages.set(this, new Set());
+        _QuickJSSandbox_pendingHostOperations.set(this, new Set());
+        _QuickJSSandbox_transportInbox.set(this, []);
+        _QuickJSSandbox_asyncError.set(this, void 0);
+        _QuickJSSandbox_host.set(this, void 0);
+        _QuickJSSandbox_hostBridge.set(this, void 0);
+        _QuickJSSandbox_flushPromise.set(this, void 0);
+        _QuickJSSandbox_disposed.set(this, false);
+        _QuickJSSandbox_initialized.set(this, false);
+        __classPrivateFieldSet(this, _QuickJSSandbox_options, options, "f");
+    }
+    async initialize() {
+        __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_assertAlive).call(this);
+        if (__classPrivateFieldGet(this, _QuickJSSandbox_initialized, "f")) {
+            return;
+        }
+        try {
+            await (0, temp_files_1.ensureDevBrowserTempDir)();
+            __classPrivateFieldSet(this, _QuickJSSandbox_host, await quickjs_host_1.QuickJSHost.create({
+                memoryLimitBytes: __classPrivateFieldGet(this, _QuickJSSandbox_options, "f").memoryLimitBytes ?? DEFAULT_MEMORY_LIMIT_BYTES,
+                cpuTimeoutMs: __classPrivateFieldGet(this, _QuickJSSandbox_options, "f").timeoutMs,
+                hostFunctions: {
+                    getPage: (name) => __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_getPage).call(this, name),
+                    newPage: () => __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_newPage).call(this),
+                    listPages: () => __classPrivateFieldGet(this, _QuickJSSandbox_options, "f").manager.listPages(__classPrivateFieldGet(this, _QuickJSSandbox_options, "f").browserName),
+                    closePage: (name) => __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_closePage).call(this, name),
+                    saveScreenshot: (name, data) => __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_writeTempFile).call(this, name, data),
+                    writeFile: (name, data) => __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_writeTempFile).call(this, name, data),
+                    readFile: (name) => __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_readTempFile).call(this, name),
+                },
+                onConsole: (level, args) => {
+                    __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_routeConsole).call(this, level, args);
+                },
+                onDrain: () => __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_drainAsyncOps).call(this),
+                onTransportSend: (message) => {
+                    __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_handleTransportSend).call(this, message);
+                },
+            }), "f");
+            __classPrivateFieldGet(this, _QuickJSSandbox_host, "f").executeScriptSync(`
+          const __performanceOrigin = Date.now();
+          const __base64Alphabet =
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+          const __encodeBase64 = (bytes) => {
+            let result = "";
+            for (let index = 0; index < bytes.length; index += 3) {
+              const chunk =
+                (bytes[index] << 16) |
+                ((bytes[index + 1] ?? 0) << 8) |
+                (bytes[index + 2] ?? 0);
+              result += __base64Alphabet[(chunk >> 18) & 63];
+              result += __base64Alphabet[(chunk >> 12) & 63];
+              result += index + 1 < bytes.length ? __base64Alphabet[(chunk >> 6) & 63] : "=";
+              result += index + 2 < bytes.length ? __base64Alphabet[chunk & 63] : "=";
+            }
+            return result;
+          };
+
+          const __decodeBase64 = (base64) => {
+            const normalized = String(base64).replace(/\\s+/g, "");
+            const output = [];
+            for (let index = 0; index < normalized.length; index += 4) {
+              const a = __base64Alphabet.indexOf(normalized[index] ?? "A");
+              const b = __base64Alphabet.indexOf(normalized[index + 1] ?? "A");
+              const c =
+                normalized[index + 2] === "="
+                  ? 64
+                  : __base64Alphabet.indexOf(normalized[index + 2] ?? "A");
+              const d =
+                normalized[index + 3] === "="
+                  ? 64
+                  : __base64Alphabet.indexOf(normalized[index + 3] ?? "A");
+              const chunk = (a << 18) | (b << 12) | ((c & 63) << 6) | (d & 63);
+              output.push((chunk >> 16) & 255);
+              if (c !== 64) {
+                output.push((chunk >> 8) & 255);
+              }
+              if (d !== 64) {
+                output.push(chunk & 255);
+              }
+            }
+            return new Uint8Array(output);
+          };
+
+          globalThis.URL ??= class URL {
+            constructor(value, base) {
+              this.href = base === undefined ? String(value) : String(base) + String(value);
+            }
+
+            toJSON() {
+              return this.href;
+            }
+
+            toString() {
+              return this.href;
+            }
+          };
+
+          globalThis.Buffer ??= class Buffer extends Uint8Array {
+            constructor(value, byteOffset, length) {
+              if (typeof value === "number") {
+                super(value);
+                return;
+              }
+              if (value instanceof ArrayBuffer) {
+                super(value, byteOffset, length);
+                return;
+              }
+              if (ArrayBuffer.isView(value)) {
+                super(value.buffer, value.byteOffset, value.byteLength);
+                return;
+              }
+              super(value);
+            }
+
+            static from(value, encodingOrOffset, length) {
+              if (typeof value === "string") {
+                if (encodingOrOffset !== undefined && encodingOrOffset !== "base64") {
+                  throw new Error("QuickJS Buffer only supports base64 string input");
+                }
+                return new Buffer(__decodeBase64(value));
+              }
+              if (value instanceof ArrayBuffer) {
+                return new Buffer(value, encodingOrOffset, length);
+              }
+              if (ArrayBuffer.isView(value)) {
+                return new Buffer(
+                  value.buffer.slice(
+                    value.byteOffset,
+                    value.byteOffset + value.byteLength,
+                  ),
+                );
+              }
+              if (Array.isArray(value)) {
+                return new Buffer(value);
+              }
+              throw new TypeError("Unsupported Buffer.from input");
+            }
+
+            toString(encoding) {
+              if (encoding === undefined || encoding === "utf8") {
+                return Array.from(this)
+                  .map((value) => String.fromCharCode(value))
+                  .join("");
+              }
+              if (encoding === "base64") {
+                return __encodeBase64(this);
+              }
+              throw new Error("QuickJS Buffer only supports utf8 and base64 output");
+            }
+          };
+
+          globalThis.performance ??= {
+            now: () => Date.now() - __performanceOrigin,
+            timeOrigin: __performanceOrigin,
+          };
+          globalThis.global = globalThis;
+        `, {
+                filename: "quickjs-runtime.js",
+            });
+            const bundleCode = await getSandboxClientBundleCode();
+            const bundleFactorySource = JSON.stringify(`${bundleCode}\nreturn __PlaywrightClient;`);
+            __classPrivateFieldGet(this, _QuickJSSandbox_host, "f").executeScriptSync(`
+          globalThis.__createPlaywrightClient = () => {
+            return new Function(${bundleFactorySource})();
+          };
+        `, {
+                filename: "sandbox-client.js",
+            });
+            const browserEntry = __classPrivateFieldGet(this, _QuickJSSandbox_options, "f").manager.getBrowser(__classPrivateFieldGet(this, _QuickJSSandbox_options, "f").browserName);
+            if (!browserEntry) {
+                throw new Error(`Browser "${__classPrivateFieldGet(this, _QuickJSSandbox_options, "f").browserName}" not found. It should have been created before script execution.`);
+            }
+            __classPrivateFieldSet(this, _QuickJSSandbox_hostBridge, new host_bridge_1.HostBridge({
+                sendToSandbox: (json) => {
+                    __classPrivateFieldGet(this, _QuickJSSandbox_transportInbox, "f").push(json);
+                },
+                preLaunchedBrowser: toServerImpl(browserEntry.browser, "Playwright browser"),
+                sharedBrowser: true,
+                denyLaunch: true,
+            }), "f");
+            await __classPrivateFieldGet(this, _QuickJSSandbox_host, "f").executeScript(`
+          (() => {
+            const hostCall = globalThis.__hostCall;
+            const transportSend = globalThis.__transport_send;
+            const createPlaywrightClient = globalThis.__createPlaywrightClient;
+
+            if (typeof hostCall !== "function") {
+              throw new Error("Sandbox bridge did not expose a host-call function");
+            }
+            if (typeof transportSend !== "function") {
+              throw new Error("Sandbox bridge did not expose a transport sender");
+            }
+            if (typeof createPlaywrightClient !== "function") {
+              throw new Error("Sandbox client bundle did not expose a Playwright client factory");
+            }
+
+            if (!delete globalThis.__hostCall) {
+              globalThis.__hostCall = undefined;
+            }
+            if (!delete globalThis.__transport_send) {
+              globalThis.__transport_send = undefined;
+            }
+            if (!delete globalThis.__createPlaywrightClient) {
+              globalThis.__createPlaywrightClient = undefined;
+            }
+
+            const playwrightClient = createPlaywrightClient();
+            const connection = new playwrightClient.Connection(playwrightClient.quickjsPlatform);
+            connection.onmessage = (message) => {
+              transportSend(JSON.stringify(message));
+            };
+
+            Object.defineProperty(globalThis, "${TRANSPORT_RECEIVE_GLOBAL}", {
+              value: (json) => {
+                connection.dispatch(JSON.parse(json));
+              },
+              configurable: false,
+              enumerable: false,
+              writable: false,
+            });
+
+            const waitForConnectionObject = async (guid, label) => {
+              if (typeof guid !== "string" || guid.length === 0) {
+                throw new Error(\`\${label} did not return a valid guid\`);
+              }
+
+              for (let attempt = 0; attempt < ${WAIT_FOR_OBJECT_ATTEMPTS}; attempt += 1) {
+                const object = connection.getObjectWithKnownName(guid);
+                if (object) {
+                  return object;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 0));
+              }
+
+              throw new Error(\`Timed out waiting for \${label} (\${guid}) in the sandbox\`);
+            };
+
+            const encodeHostFilePayload = (value) => {
+              if (typeof value === "string") {
+                return { encoding: "utf8", data: value };
+              }
+              if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+                return { encoding: "base64", data: Buffer.from(value).toString("base64") };
+              }
+              throw new TypeError(
+                "File data must be a string, Buffer, Uint8Array, or ArrayBuffer",
+              );
+            };
+
+            return (async () => {
+              await connection.initializePlaywright();
+
+              const browserApi = Object.create(null);
+              Object.defineProperties(browserApi, {
+                getPage: {
+                  value: async (name) => {
+                    const guid = await hostCall("getPage", JSON.stringify([name]));
+                    return await waitForConnectionObject(guid, \`page "\${name}"\`);
+                  },
+                  enumerable: true,
+                },
+                newPage: {
+                  value: async () => {
+                    const guid = await hostCall("newPage", JSON.stringify([]));
+                    return await waitForConnectionObject(guid, "anonymous page");
+                  },
+                  enumerable: true,
+                },
+                listPages: {
+                  value: async () => {
+                    return await hostCall("listPages", JSON.stringify([]));
+                  },
+                  enumerable: true,
+                },
+                closePage: {
+                  value: async (name) => {
+                    await hostCall("closePage", JSON.stringify([name]));
+                  },
+                  enumerable: true,
+                },
+              });
+              Object.freeze(browserApi);
+
+              Object.defineProperty(globalThis, "browser", {
+                value: browserApi,
+                configurable: false,
+                enumerable: true,
+                writable: false,
+              });
+
+              Object.defineProperties(globalThis, {
+                saveScreenshot: {
+                  value: async (buffer, name) => {
+                    return await hostCall(
+                      "saveScreenshot",
+                      JSON.stringify([name, encodeHostFilePayload(buffer)]),
+                    );
+                  },
+                  configurable: false,
+                  enumerable: true,
+                  writable: false,
+                },
+                writeFile: {
+                  value: async (name, data) => {
+                    return await hostCall(
+                      "writeFile",
+                      JSON.stringify([name, encodeHostFilePayload(data)]),
+                    );
+                  },
+                  configurable: false,
+                  enumerable: true,
+                  writable: false,
+                },
+                readFile: {
+                  value: async (name) => {
+                    return await hostCall("readFile", JSON.stringify([name]));
+                  },
+                  configurable: false,
+                  enumerable: true,
+                  writable: false,
+                },
+              });
+            })();
+          })()
+        `, {
+                filename: "sandbox-init.js",
+            });
+            await __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_flushTransportQueue).call(this);
+            __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_throwIfAsyncError).call(this);
+            __classPrivateFieldSet(this, _QuickJSSandbox_initialized, true, "f");
+        }
+        catch (error) {
+            await this.dispose();
+            throw error;
+        }
+    }
+    async executeScript(script) {
+        __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_assertInitialized).call(this);
+        let executionError;
+        try {
+            __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_throwIfAsyncError).call(this);
+            await __classPrivateFieldGet(this, _QuickJSSandbox_host, "f").executeScript(wrapScriptWithWallClockTimeout(script, __classPrivateFieldGet(this, _QuickJSSandbox_options, "f").timeoutMs), {
+                filename: "user-script.js",
+            });
+            await __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_flushTransportQueue).call(this);
+            __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_throwIfAsyncError).call(this);
+        }
+        catch (error) {
+            executionError = error;
+        }
+        try {
+            await __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_cleanupAnonymousPages).call(this);
+        }
+        catch (error) {
+            executionError ?? (executionError = error);
+        }
+        if (executionError) {
+            throw executionError;
+        }
+    }
+    async dispose() {
+        if (__classPrivateFieldGet(this, _QuickJSSandbox_disposed, "f")) {
+            return;
+        }
+        __classPrivateFieldSet(this, _QuickJSSandbox_disposed, true, "f");
+        await __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_cleanupAnonymousPages).call(this, {
+            suppressErrors: true,
+        });
+        __classPrivateFieldGet(this, _QuickJSSandbox_transportInbox, "f").length = 0;
+        __classPrivateFieldGet(this, _QuickJSSandbox_pendingHostOperations, "f").clear();
+        try {
+            await __classPrivateFieldGet(this, _QuickJSSandbox_hostBridge, "f")?.dispose();
+        }
+        catch {
+            // Best effort cleanup during sandbox teardown.
+        }
+        finally {
+            __classPrivateFieldSet(this, _QuickJSSandbox_hostBridge, undefined, "f");
+            __classPrivateFieldGet(this, _QuickJSSandbox_host, "f")?.dispose();
+            __classPrivateFieldSet(this, _QuickJSSandbox_host, undefined, "f");
+            __classPrivateFieldSet(this, _QuickJSSandbox_flushPromise, undefined, "f");
+        }
+    }
+}
+exports.QuickJSSandbox = QuickJSSandbox;
+_QuickJSSandbox_options = new WeakMap(), _QuickJSSandbox_anonymousPages = new WeakMap(), _QuickJSSandbox_pendingHostOperations = new WeakMap(), _QuickJSSandbox_transportInbox = new WeakMap(), _QuickJSSandbox_asyncError = new WeakMap(), _QuickJSSandbox_host = new WeakMap(), _QuickJSSandbox_hostBridge = new WeakMap(), _QuickJSSandbox_flushPromise = new WeakMap(), _QuickJSSandbox_disposed = new WeakMap(), _QuickJSSandbox_initialized = new WeakMap(), _QuickJSSandbox_instances = new WeakSet(), _QuickJSSandbox_routeConsole = function _QuickJSSandbox_routeConsole(level, args) {
+    const line = `${formatArgs(args)}\n`;
+    if (level === "warn" || level === "error") {
+        __classPrivateFieldGet(this, _QuickJSSandbox_options, "f").onStderr(line);
+        return;
+    }
+    __classPrivateFieldGet(this, _QuickJSSandbox_options, "f").onStdout(line);
+}, _QuickJSSandbox_handleTransportSend = function _QuickJSSandbox_handleTransportSend(message) {
+    if (!__classPrivateFieldGet(this, _QuickJSSandbox_hostBridge, "f")) {
+        __classPrivateFieldSet(this, _QuickJSSandbox_asyncError, __classPrivateFieldGet(this, _QuickJSSandbox_asyncError, "f") ?? new Error("Sandbox transport is not initialized"), "f");
+        return;
+    }
+    const operation = __classPrivateFieldGet(this, _QuickJSSandbox_hostBridge, "f")
+        .receiveFromSandbox(message)
+        .catch((error) => {
+        __classPrivateFieldSet(this, _QuickJSSandbox_asyncError, __classPrivateFieldGet(this, _QuickJSSandbox_asyncError, "f") ?? normalizeError(error), "f");
+    })
+        .finally(() => {
+        __classPrivateFieldGet(this, _QuickJSSandbox_pendingHostOperations, "f").delete(operation);
+    });
+    __classPrivateFieldGet(this, _QuickJSSandbox_pendingHostOperations, "f").add(operation);
+}, _QuickJSSandbox_drainAsyncOps = async function _QuickJSSandbox_drainAsyncOps() {
+    __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_throwIfAsyncError).call(this);
+    await __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_flushTransportQueue).call(this);
+    __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_throwIfAsyncError).call(this);
+    if (__classPrivateFieldGet(this, _QuickJSSandbox_pendingHostOperations, "f").size === 0) {
+        return;
+    }
+    await Promise.race(__classPrivateFieldGet(this, _QuickJSSandbox_pendingHostOperations, "f"));
+    __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_throwIfAsyncError).call(this);
+    await __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_flushTransportQueue).call(this);
+    __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_throwIfAsyncError).call(this);
+}, _QuickJSSandbox_flushTransportQueue = async function _QuickJSSandbox_flushTransportQueue() {
+    __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_throwIfAsyncError).call(this);
+    if (!__classPrivateFieldGet(this, _QuickJSSandbox_host, "f") || __classPrivateFieldGet(this, _QuickJSSandbox_transportInbox, "f").length === 0) {
+        return;
+    }
+    if (__classPrivateFieldGet(this, _QuickJSSandbox_flushPromise, "f")) {
+        await __classPrivateFieldGet(this, _QuickJSSandbox_flushPromise, "f");
+        return;
+    }
+    const flush = async () => {
+        while (__classPrivateFieldGet(this, _QuickJSSandbox_transportInbox, "f").length > 0) {
+            const message = __classPrivateFieldGet(this, _QuickJSSandbox_transportInbox, "f").shift();
+            if (message === undefined) {
+                continue;
+            }
+            await __classPrivateFieldGet(this, _QuickJSSandbox_host, "f").callFunction(TRANSPORT_RECEIVE_GLOBAL, message);
+            __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_throwIfAsyncError).call(this);
+        }
+    };
+    __classPrivateFieldSet(this, _QuickJSSandbox_flushPromise, flush().finally(() => {
+        __classPrivateFieldSet(this, _QuickJSSandbox_flushPromise, undefined, "f");
+    }), "f");
+    await __classPrivateFieldGet(this, _QuickJSSandbox_flushPromise, "f");
+}, _QuickJSSandbox_getPage = async function _QuickJSSandbox_getPage(name) {
+    const page = await __classPrivateFieldGet(this, _QuickJSSandbox_options, "f").manager.getPage(__classPrivateFieldGet(this, _QuickJSSandbox_options, "f").browserName, requireString(name, "Page name or targetId"));
+    return extractGuid(page);
+}, _QuickJSSandbox_newPage = async function _QuickJSSandbox_newPage() {
+    const page = await __classPrivateFieldGet(this, _QuickJSSandbox_options, "f").manager.newPage(__classPrivateFieldGet(this, _QuickJSSandbox_options, "f").browserName);
+    __classPrivateFieldGet(this, _QuickJSSandbox_anonymousPages, "f").add(page);
+    page.on("close", () => {
+        __classPrivateFieldGet(this, _QuickJSSandbox_anonymousPages, "f").delete(page);
+    });
+    return extractGuid(page);
+}, _QuickJSSandbox_closePage = async function _QuickJSSandbox_closePage(name) {
+    await __classPrivateFieldGet(this, _QuickJSSandbox_options, "f").manager.closePage(__classPrivateFieldGet(this, _QuickJSSandbox_options, "f").browserName, requireString(name, "Page name"));
+}, _QuickJSSandbox_writeTempFile = async function _QuickJSSandbox_writeTempFile(name, payload) {
+    return await (0, temp_files_1.writeDevBrowserTempFile)(requireString(name, "File name"), decodeSandboxFilePayload(payload, "File data"));
+}, _QuickJSSandbox_readTempFile = async function _QuickJSSandbox_readTempFile(name) {
+    return await (0, temp_files_1.readDevBrowserTempFile)(requireString(name, "File name"));
+}, _QuickJSSandbox_cleanupAnonymousPages = async function _QuickJSSandbox_cleanupAnonymousPages(options = {}) {
+    const anonymousPages = [...__classPrivateFieldGet(this, _QuickJSSandbox_anonymousPages, "f")];
+    __classPrivateFieldGet(this, _QuickJSSandbox_anonymousPages, "f").clear();
+    for (const page of anonymousPages) {
+        try {
+            if (!page.isClosed()) {
+                await page.close();
+            }
+        }
+        catch (error) {
+            if (!options.suppressErrors) {
+                throw error;
+            }
+        }
+    }
+    if (options.suppressErrors) {
+        try {
+            await __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_flushTransportQueue).call(this);
+        }
+        catch {
+            // Best effort cleanup during sandbox teardown.
+        }
+        return;
+    }
+    await __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_flushTransportQueue).call(this);
+    __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_throwIfAsyncError).call(this);
+}, _QuickJSSandbox_throwIfAsyncError = function _QuickJSSandbox_throwIfAsyncError() {
+    if (__classPrivateFieldGet(this, _QuickJSSandbox_asyncError, "f")) {
+        throw __classPrivateFieldGet(this, _QuickJSSandbox_asyncError, "f");
+    }
+}, _QuickJSSandbox_assertAlive = function _QuickJSSandbox_assertAlive() {
+    if (__classPrivateFieldGet(this, _QuickJSSandbox_disposed, "f")) {
+        throw new Error("QuickJS sandbox has been disposed");
+    }
+}, _QuickJSSandbox_assertInitialized = function _QuickJSSandbox_assertInitialized() {
+    __classPrivateFieldGet(this, _QuickJSSandbox_instances, "m", _QuickJSSandbox_assertAlive).call(this);
+    if (!__classPrivateFieldGet(this, _QuickJSSandbox_initialized, "f") || !__classPrivateFieldGet(this, _QuickJSSandbox_host, "f") || !__classPrivateFieldGet(this, _QuickJSSandbox_hostBridge, "f")) {
+        throw new Error("QuickJS sandbox has not been initialized");
+    }
+};
+//# sourceMappingURL=quickjs-sandbox.js.map