dorkos 0.98.0 → 0.101.0

package/dist/browser/native/darwin-supervisor-worker.mjs

@@ -0,0 +1,1996 @@
+// packages/browser/src/lifecycle/errors.ts
+var codes = /* @__PURE__ */ new Set([
+  "BROWSER_LAUNCH_TIMEOUT",
+  "BROWSER_STOPPED",
+  "CAPTURE_FAILED",
+  "CAPTURE_LIMIT",
+  "CAPTURE_QUEUE_FULL",
+  "CAPTURE_TIMEOUT",
+  "COMMAND_UNSUPPORTED",
+  "CONTEXT_CLOSE_TIMEOUT",
+  "COUNTER_EXHAUSTED",
+  "ENGINE_STOPPED",
+  "EXECUTABLE_UNAVAILABLE",
+  "FIXTURE_PROXY_CLOSE_FAILED",
+  "FIXTURE_PROXY_UNAVAILABLE",
+  "IDENTITY_MODE_UNAVAILABLE",
+  "INITIAL_NAVIGATION_FAILED",
+  "LIBRARY_UNAVAILABLE",
+  "NETWORK_POLICY_UNSUPPORTED",
+  "OPEN_FAILED",
+  "OPERATION_FAILED",
+  "PAGE_UNAVAILABLE",
+  "PLATFORM_UNSUPPORTED",
+  "POLICY_REFUSED",
+  "POLICY_UNAVAILABLE",
+  "PROCESS_ATTRIBUTION_UNAVAILABLE",
+  "PROCESS_OBSERVATION_UNAVAILABLE",
+  "PROFILE_IN_USE",
+  "PROFILE_SETUP_FAILED",
+  "PROFILE_UNCERTAIN",
+  "RUNTIME_UNAVAILABLE",
+  "STALE_BINDING",
+  "UNKNOWN_NATIVE_HOLDER",
+  "UNSAFE_DIRECTORY"
+]);
+var cleanupCodes = /* @__PURE__ */ new Set([
+  "PROFILE_UNCERTAIN",
+  "observationUnavailable",
+  "closeFailed",
+  "processesRemain"
+]);
+var BrowserLifecycleError = class extends Error {
+  code;
+  cleanupCode;
+  constructor(code, cleanupCode) {
+    const fixed = codes.has(code) ? code : "OPERATION_FAILED";
+    super(`Browser lifecycle failed: ${fixed}`);
+    this.name = "BrowserLifecycleError";
+    this.code = fixed;
+    if (cleanupCode !== void 0)
+      this.cleanupCode = cleanupCodes.has(cleanupCode) ? cleanupCode : "observationUnavailable";
+    Object.freeze(this);
+  }
+};
+
+// packages/browser/src/runtime/default-downloads.ts
+var DefaultDownloadOwner = class {
+  constructor(browser, current, lost) {
+    this.browser = browser;
+    this.current = current;
+    this.lost = lost;
+    this.ready = Promise.resolve().then(() => {
+      if (this.failure) throw this.failure.value;
+      return this.acquire();
+    });
+    void this.ready.catch((value) => {
+      this.failure ??= Object.freeze({ value });
+    });
+    try {
+      const on = browser.on;
+      if (this.closing) throw new BrowserLifecycleError("ENGINE_STOPPED");
+      const off = browser.off;
+      if (this.closing) throw new BrowserLifecycleError("ENGINE_STOPPED");
+      const disconnected = (original) => {
+        if (original === this.browser) this.browserDisconnected = true;
+        if (original !== this.browser || !this.closing) {
+          this.failure ??= Object.freeze({
+            value: new BrowserLifecycleError("OPERATION_FAILED")
+          });
+          try {
+            this.lost();
+          } catch (value) {
+            this.failure ??= Object.freeze({ value });
+          }
+        }
+      };
+      this.removeBrowser = () => {
+        Reflect.apply(off, browser, ["disconnected", disconnected]);
+      };
+      Reflect.apply(on, browser, ["disconnected", disconnected]);
+    } catch (value) {
+      this.failure ??= Object.freeze({ value });
+    }
+  }
+  browser;
+  current;
+  lost;
+  ready;
+  session;
+  detach;
+  remove;
+  removeBrowser;
+  browserDisconnected = false;
+  closing = false;
+  sessionClosed = false;
+  joined;
+  failure;
+  admitted() {
+    if (this.closing || !this.current()) throw new BrowserLifecycleError("ENGINE_STOPPED");
+  }
+  async acquire() {
+    this.admitted();
+    const contexts = this.browser.contexts;
+    const create = this.browser.newBrowserCDPSession;
+    this.admitted();
+    const original = Reflect.apply(contexts, this.browser, []);
+    this.admitted();
+    if (original.length !== 1) throw new BrowserLifecycleError("PAGE_UNAVAILABLE");
+    const sameContext = () => {
+      this.admitted();
+      const now = Reflect.apply(contexts, this.browser, []);
+      if (now.length !== 1 || now[0] !== original[0])
+        throw new BrowserLifecycleError("PAGE_UNAVAILABLE");
+      this.admitted();
+    };
+    sameContext();
+    const session = await Reflect.apply(create, this.browser, []);
+    this.session = session;
+    this.detach = session.detach;
+    const on = session.on;
+    const off = session.off;
+    const closed = () => {
+      this.sessionClosed = true;
+      if (!this.closing) {
+        this.failure ??= Object.freeze({
+          value: new BrowserLifecycleError("OPERATION_FAILED")
+        });
+        try {
+          this.lost();
+        } catch (value) {
+          this.failure ??= Object.freeze({ value });
+        }
+      }
+    };
+    this.remove = () => {
+      Reflect.apply(off, session, ["close", closed]);
+    };
+    this.admitted();
+    Reflect.apply(on, session, ["close", closed]);
+    const send = session.send;
+    sameContext();
+    await Reflect.apply(send, session, [
+      "Browser.setDownloadBehavior",
+      { behavior: "deny", eventsEnabled: false }
+    ]);
+    sameContext();
+    if (this.failure) throw this.failure.value;
+    if (this.sessionClosed) throw new BrowserLifecycleError("OPERATION_FAILED");
+  }
+  /** Fence initialization and mark expected SDK closure without releasing the deny override. */
+  retire() {
+    this.closing = true;
+  }
+  /** Join original initialization and session cleanup after actual browser shutdown entry. */
+  close() {
+    this.retire();
+    if (this.joined) return this.joined;
+    this.joined = Promise.resolve().then(async () => {
+      try {
+        await this.ready;
+      } catch (value) {
+        this.failure ??= Object.freeze({ value });
+      }
+      try {
+        if (this.session && !this.sessionClosed && !this.browserDisconnected) {
+          if (!this.detach) throw new BrowserLifecycleError("OPERATION_FAILED");
+          await Reflect.apply(this.detach, this.session, []);
+        }
+      } catch (value) {
+        this.failure ??= Object.freeze({ value });
+      }
+      try {
+        this.remove?.();
+      } catch (value) {
+        this.failure ??= Object.freeze({ value });
+      }
+      try {
+        this.removeBrowser?.();
+      } catch (value) {
+        this.failure ??= Object.freeze({ value });
+      }
+      if (this.failure) throw this.failure.value;
+    });
+    void this.joined.catch(() => {
+    });
+    return this.joined;
+  }
+};
+async function closeBrowserAndDownloads(browser, downloads) {
+  let first;
+  try {
+    await browser?.close();
+  } catch (value) {
+    first = { value };
+  }
+  try {
+    await downloads?.close();
+  } catch (value) {
+    first ??= { value };
+  }
+  if (first) throw first.value;
+}
+
+// packages/browser/src/runtime/private-proxy-auth.ts
+var retained = /* @__PURE__ */ new Set();
+async function ownPrivateProxyAuthentication(endpoint2, peer, failed) {
+  const proxy = new URL(peer.url);
+  if (proxy.origin !== peer.url || proxy.protocol !== "http:" || proxy.hostname !== "127.0.0.1" || !proxy.port)
+    throw new Error("PROXY_AUTH_PEER_INVALID");
+  const socket = new WebSocket(endpoint2);
+  const pending = /* @__PURE__ */ new Map();
+  const tasks = /* @__PURE__ */ new Set();
+  const sessions = /* @__PURE__ */ new Set();
+  const fetchFrames = /* @__PURE__ */ new Set();
+  const workerParents = /* @__PURE__ */ new Map();
+  const coveredWorker = (sessionId) => {
+    const visited = /* @__PURE__ */ new Set();
+    let current = sessionId;
+    while (sessions.has(current) && visited.size < 128 && !visited.has(current)) {
+      if (fetchFrames.has(current)) return true;
+      visited.add(current);
+      const parent = workerParents.get(current);
+      if (!parent) return false;
+      current = parent;
+    }
+    return false;
+  };
+  const attempts = /* @__PURE__ */ new Set();
+  const originalOwner = { socket, pending, tasks, sessions, fetchFrames, workerParents };
+  retained.add(originalOwner);
+  let sequence2 = 0, stopping = false, uncertain = false, closing;
+  const terminal = new Promise(
+    (resolve) => socket.addEventListener(
+      "close",
+      () => {
+        if (!stopping) fault();
+        for (const request of pending.values()) {
+          clearTimeout(request.timer);
+          request.reject(new Error("PROXY_AUTH_CHANNEL_CLOSED"));
+        }
+        pending.clear();
+        resolve();
+      },
+      { once: true }
+    )
+  );
+  const targetTypes = /* @__PURE__ */ new Set([
+    "page",
+    "iframe",
+    "worker",
+    "shared_worker",
+    "service_worker",
+    "worklet",
+    "auction_worklet",
+    "background_page",
+    "webview",
+    "browser",
+    "tab",
+    "other"
+  ]);
+  function fault() {
+    if (uncertain) return;
+    uncertain = true;
+    failed();
+  }
+  function send(method, params, sessionId) {
+    if (stopping || uncertain || socket.readyState !== WebSocket.OPEN || pending.size >= 128 || sequence2 >= Number.MAX_SAFE_INTEGER)
+      return Promise.reject(new Error("PROXY_AUTH_CHANNEL_UNAVAILABLE"));
+    const id = ++sequence2;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error("PROXY_AUTH_METHOD_TIMEOUT"));
+        fault();
+      }, 3e3);
+      pending.set(id, { resolve, reject, timer });
+      try {
+        socket.send(JSON.stringify({ id, method, params, ...sessionId ? { sessionId } : {} }));
+      } catch {
+        clearTimeout(timer);
+        pending.delete(id);
+        reject(new Error("PROXY_AUTH_SEND_FAILED"));
+        fault();
+      }
+    });
+  }
+  const filters = [{ type: "browser", exclude: true }, { type: "tab", exclude: true }, {}];
+  async function attach(sessionId, targetType, parentSessionId) {
+    if (sessions.has(sessionId) || sessions.size >= 128)
+      throw new Error("PROXY_AUTH_TARGET_UNAVAILABLE");
+    sessions.add(sessionId);
+    if (targetType === "worker") {
+      if (!parentSessionId || !coveredWorker(parentSessionId))
+        throw new Error("PROXY_AUTH_WORKER_PARENT_UNAVAILABLE");
+      workerParents.set(sessionId, parentSessionId);
+    } else {
+      await send(
+        "Fetch.enable",
+        { handleAuthRequests: true, patterns: [{ urlPattern: "*" }] },
+        sessionId
+      );
+      if (targetType === "page" || targetType === "iframe") fetchFrames.add(sessionId);
+    }
+    await send(
+      "Target.setAutoAttach",
+      { autoAttach: true, waitForDebuggerOnStart: true, flatten: true, filter: filters },
+      sessionId
+    );
+    if (targetType === "worker" && !coveredWorker(sessionId))
+      throw new Error("PROXY_AUTH_WORKER_PARENT_UNAVAILABLE");
+    await send("Runtime.runIfWaitingForDebugger", {}, sessionId);
+  }
+  function own(task) {
+    if (tasks.size >= 128) {
+      fault();
+      void task.catch(() => {
+      });
+      return;
+    }
+    tasks.add(task);
+    void task.then(
+      () => tasks.delete(task),
+      () => {
+        tasks.delete(task);
+        if (!stopping) fault();
+      }
+    );
+  }
+  socket.addEventListener("error", () => {
+    if (!stopping) fault();
+  });
+  socket.addEventListener("message", (event) => {
+    if (stopping || uncertain) return;
+    if (typeof event.data !== "string" || Buffer.byteLength(event.data) > 65536) {
+      fault();
+      return;
+    }
+    let value;
+    try {
+      value = JSON.parse(event.data);
+    } catch {
+      fault();
+      return;
+    }
+    if (!value || typeof value !== "object") {
+      fault();
+      return;
+    }
+    if (typeof value.id === "number") {
+      const original = pending.get(value.id);
+      if (!original) {
+        fault();
+        return;
+      }
+      pending.delete(value.id);
+      clearTimeout(original.timer);
+      if (value.error) original.reject(new Error("PROXY_AUTH_METHOD_REFUSED"));
+      else original.resolve(value.result);
+      return;
+    }
+    const params = value.params;
+    if (value.method === "Target.attachedToTarget") {
+      if (!params || typeof params.sessionId !== "string") {
+        fault();
+        return;
+      }
+      const info = params.targetInfo;
+      const type = info && typeof info === "object" ? info.type : void 0;
+      own(
+        attach(
+          params.sessionId,
+          typeof type === "string" && targetTypes.has(type) ? type : "unknown",
+          value.sessionId
+        )
+      );
+    } else if (value.method === "Target.detachedFromTarget") {
+      if (params && typeof params.sessionId === "string") {
+        sessions.delete(params.sessionId);
+        fetchFrames.delete(params.sessionId);
+        workerParents.delete(params.sessionId);
+      }
+    } else if (value.method === "Fetch.requestPaused") {
+      if (!params || typeof params.requestId !== "string" || !value.sessionId || !sessions.has(value.sessionId)) {
+        fault();
+        return;
+      }
+      own(
+        send("Fetch.continueRequest", { requestId: params.requestId }, value.sessionId).then(
+          () => {
+          }
+        )
+      );
+    } else if (value.method === "Fetch.authRequired") {
+      if (!params || typeof params.requestId !== "string" || !value.sessionId || !sessions.has(value.sessionId)) {
+        fault();
+        return;
+      }
+      const challenge = params.authChallenge;
+      const attempt = `${value.sessionId}:${params.requestId}`;
+      const first = !attempts.has(attempt);
+      let exact = false;
+      attempts.add(attempt);
+      if (attempts.size > 4096) {
+        fault();
+        return;
+      }
+      try {
+        exact = first && challenge?.source === "Proxy" && new URL(challenge.origin).origin === peer.url;
+      } catch {
+      }
+      own(
+        send(
+          "Fetch.continueWithAuth",
+          {
+            requestId: params.requestId,
+            authChallengeResponse: exact ? {
+              response: "ProvideCredentials",
+              username: peer.credentials.username,
+              password: peer.credentials.password
+            } : { response: "CancelAuth" }
+          },
+          value.sessionId
+        ).then(() => {
+        })
+      );
+    }
+  });
+  const opened = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("PROXY_AUTH_OPEN_TIMEOUT")), 3e3);
+    socket.addEventListener(
+      "open",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true }
+    );
+    socket.addEventListener(
+      "error",
+      () => {
+        clearTimeout(timer);
+        reject(new Error("PROXY_AUTH_OPEN_FAILED"));
+      },
+      { once: true }
+    );
+  });
+  const close = () => {
+    if (closing) return closing;
+    stopping = true;
+    socket.close();
+    closing = Promise.all([terminal, ...tasks]).then(() => {
+      if (uncertain) throw new Error("PROXY_AUTH_CUSTODY_UNCERTAIN");
+      retained.delete(originalOwner);
+    });
+    return closing;
+  };
+  try {
+    await opened;
+    await send("Target.setAutoAttach", {
+      autoAttach: true,
+      waitForDebuggerOnStart: true,
+      flatten: true,
+      filter: filters
+    });
+    while (tasks.size) await Promise.all([...tasks]);
+    if (uncertain) throw new Error("PROXY_AUTH_CUSTODY_UNCERTAIN");
+  } catch (error) {
+    fault();
+    void close().catch(() => {
+    });
+    throw error;
+  }
+  return Object.freeze({
+    isCustodyKnown: () => !stopping && !uncertain && socket.readyState === WebSocket.OPEN,
+    close
+  });
+}
+
+// packages/browser/src/runtime/darwin-supervisor-browser.ts
+import { constants as constants4 } from "node:fs";
+import { open as open3, lstat as lstat3 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+
+// packages/browser/src/runtime/public-library.ts
+import { createRequire } from "node:module";
+import { access, realpath, stat, readdir, lstat, open, readlink } from "node:fs/promises";
+import { constants } from "node:fs";
+import { createHash } from "node:crypto";
+import { join, relative } from "node:path";
+var PUBLIC_DISTRIBUTION_SHA256 = "6bf8e6d392f411f43046a5688021a5ed083fea9129f2f84dbff5aee88b2de728";
+var retainedReads = /* @__PURE__ */ new Set();
+var closeUncertain = false;
+function requireClosedReads() {
+  if (closeUncertain) throw new BrowserLifecycleError("LIBRARY_UNAVAILABLE");
+}
+async function closeOriginal(file) {
+  try {
+    await file.close();
+    retainedReads.delete(file);
+  } catch (error) {
+    closeUncertain = true;
+    throw error;
+  }
+}
+function sameFile(a, b) {
+  return a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
+}
+function requireLibrary(value) {
+  if (!value) throw new BrowserLifecycleError("LIBRARY_UNAVAILABLE");
+}
+async function hashFile(path, cap = 2 * 1024 * 1024 * 1024) {
+  requireClosedReads();
+  const named = await lstat(path, { bigint: true });
+  requireLibrary(named.isFile() && named.size <= BigInt(cap));
+  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  retainedReads.add(file);
+  let failed = false, primary, digest = "";
+  try {
+    const before = await file.stat({ bigint: true });
+    requireLibrary(sameFile(named, before));
+    const hash = createHash("sha256"), buffer = Buffer.alloc(65536);
+    let bytes = 0;
+    for (; ; ) {
+      const read = await file.read(buffer, 0, Math.min(buffer.length, cap + 1 - bytes), bytes);
+      if (!read.bytesRead) break;
+      bytes += read.bytesRead;
+      requireLibrary(bytes <= cap);
+      hash.update(buffer.subarray(0, read.bytesRead));
+    }
+    requireLibrary(
+      BigInt(bytes) === before.size && sameFile(before, await file.stat({ bigint: true })) && sameFile(before, await lstat(path, { bigint: true }))
+    );
+    digest = hash.digest("hex");
+  } catch (error) {
+    failed = true;
+    primary = error;
+  }
+  try {
+    await closeOriginal(file);
+  } catch (error) {
+    if (!failed) primary = error;
+    failed = true;
+  }
+  if (failed) throw primary;
+  return digest;
+}
+async function metadataText(path) {
+  requireClosedReads();
+  const cap = 65536;
+  const named = await lstat(path, { bigint: true });
+  requireLibrary(named.isFile() && named.size <= BigInt(cap));
+  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  retainedReads.add(file);
+  let failed = false, primary, text2 = "";
+  try {
+    const before = await file.stat({ bigint: true });
+    requireLibrary(before.isFile() && sameFile(named, before));
+    const bytes = Buffer.alloc(cap + 1);
+    let total = 0;
+    while (total < bytes.length) {
+      const read = await file.read(bytes, total, bytes.length - total, total);
+      if (!read.bytesRead) break;
+      total += read.bytesRead;
+      requireLibrary(total <= cap);
+    }
+    requireLibrary(
+      BigInt(total) === before.size && sameFile(before, await file.stat({ bigint: true })) && sameFile(before, await lstat(path, { bigint: true }))
+    );
+    text2 = bytes.subarray(0, total).toString("utf8");
+  } catch (error) {
+    failed = true;
+    primary = error;
+  }
+  try {
+    await closeOriginal(file);
+  } catch (error) {
+    if (!failed) primary = error;
+    failed = true;
+  }
+  if (failed) throw primary;
+  return text2;
+}
+async function directoryNames(path) {
+  requireClosedReads();
+  const named = await lstat(path, { bigint: true });
+  requireLibrary(named.isDirectory());
+  const directory = await open(
+    path,
+    constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW
+  );
+  retainedReads.add(directory);
+  let failed = false, primary, names = [];
+  try {
+    requireLibrary(sameFile(named, await directory.stat({ bigint: true })));
+    names = await readdir(path);
+    requireLibrary(names.length <= 256);
+    requireLibrary(
+      sameFile(named, await directory.stat({ bigint: true })) && sameFile(named, await lstat(path, { bigint: true }))
+    );
+  } catch (error) {
+    failed = true;
+    primary = error;
+  }
+  try {
+    await closeOriginal(directory);
+  } catch (error) {
+    if (!failed) primary = error;
+    failed = true;
+  }
+  if (failed) throw primary;
+  return { names: names.sort(), identity: named };
+}
+async function generatedLibraryMetadata(root, path) {
+  const modules = await directoryNames(path), binsPath = join(path, ".bin");
+  requireLibrary(modules.names.length === 1 && modules.names[0] === ".bin");
+  const bins = await directoryNames(binsPath);
+  requireLibrary(bins.names.length === 1 && bins.names[0] === "playwright-core");
+  const shim = join(binsPath, "playwright-core"), before = await lstat(shim, { bigint: true });
+  if (before.isSymbolicLink()) {
+    const target = await readlink(shim);
+    requireLibrary(
+      Buffer.byteLength(target) <= 65536 && await realpath(shim) === join(root, "cli.js")
+    );
+    requireLibrary(
+      sameFile(before, await lstat(shim, { bigint: true })) && target === await readlink(shim)
+    );
+  } else {
+    requireLibrary(before.isFile());
+    await hashFile(shim, 65536);
+    requireLibrary(sameFile(before, await lstat(shim, { bigint: true })));
+  }
+  requireLibrary(
+    sameFile(modules.identity, await lstat(path, { bigint: true })) && sameFile(bins.identity, await lstat(binsPath, { bigint: true }))
+  );
+}
+async function distributionHash(root) {
+  const files = [];
+  let entries = 0;
+  const visit = async (path, depth) => {
+    requireLibrary(depth <= 32);
+    const directory = await directoryNames(path);
+    for (const name of directory.names) {
+      requireLibrary(++entries <= 256);
+      const absolute = join(path, name), relativePath = relative(root, absolute);
+      const entry = await lstat(absolute, { bigint: true });
+      if (relativePath === "node_modules") {
+        requireLibrary(entry.isDirectory());
+        await generatedLibraryMetadata(root, absolute);
+      } else if (entry.isDirectory()) await visit(absolute, depth + 1);
+      else {
+        requireLibrary(entry.isFile());
+        files.push(relativePath);
+      }
+    }
+    requireLibrary(sameFile(directory.identity, await lstat(path, { bigint: true })));
+  };
+  await visit(root, 0);
+  files.sort();
+  if (files.length !== 114) throw new BrowserLifecycleError("LIBRARY_UNAVAILABLE");
+  const hash = createHash("sha256");
+  for (const file of files)
+    hash.update(file + "\0" + await hashFile(join(root, file), 32 * 1024 * 1024) + "\n");
+  return hash.digest("hex");
+}
+async function verifiedLibrary(runtime) {
+  try {
+    requireClosedReads();
+    if (runtime.identity.mode !== "native")
+      throw new BrowserLifecycleError("IDENTITY_MODE_UNAVAILABLE");
+    if (runtime.executable.platform !== process.platform || runtime.executable.arch !== process.arch || process.platform === "win32")
+      throw new BrowserLifecycleError("PLATFORM_UNSUPPORTED");
+    const root = await realpath(runtime.library.rootDir);
+    const pkg = JSON.parse(await metadataText(join(root, "package.json")));
+    const manifest = JSON.parse(
+      await metadataText(join(root, runtime.library.assets.manifest))
+    );
+    const chromium = manifest.browsers?.find((entry) => entry.name === "chromium");
+    if (pkg.name !== "playwright-core" || pkg.version !== runtime.library.version || chromium?.revision !== runtime.executable.revision || chromium.browserVersion !== runtime.executable.version)
+      throw new BrowserLifecycleError("LIBRARY_UNAVAILABLE");
+    if (!(await stat(join(root, runtime.library.assets.cli))).isFile() || await distributionHash(root) !== PUBLIC_DISTRIBUTION_SHA256)
+      throw new BrowserLifecycleError("LIBRARY_UNAVAILABLE");
+    await access(runtime.executable.path, constants.R_OK | constants.X_OK);
+    if (!(await stat(runtime.executable.path)).isFile() || await hashFile(runtime.executable.path) !== runtime.executable.sha256)
+      throw new BrowserLifecycleError("EXECUTABLE_UNAVAILABLE");
+    requireClosedReads();
+    const library = createRequire(join(root, "package.json"))(root);
+    return library.chromium;
+  } catch (error) {
+    if (error instanceof BrowserLifecycleError) throw error;
+    throw new BrowserLifecycleError("RUNTIME_UNAVAILABLE");
+  }
+}
+
+// packages/browser/src/network/fixture-proxy.ts
+import {
+  createServer,
+  request as httpRequest
+} from "node:http";
+async function startFixtureProxy(origin) {
+  if (new URL(origin).protocol !== "http:")
+    throw new BrowserLifecycleError("NETWORK_POLICY_UNSUPPORTED");
+  const pending = /* @__PURE__ */ new Set();
+  const server = createServer({ maxHeaderSize: 16 * 1024 }, (incoming, response) => {
+    let target;
+    try {
+      target = new URL(incoming.url ?? "");
+    } catch {
+      response.writeHead(403).end();
+      return;
+    }
+    if (target.origin !== origin || target.username || target.password) {
+      response.writeHead(403).end();
+      return;
+    }
+    if (pending.size >= 32) {
+      response.writeHead(503).end();
+      return;
+    }
+    const headers = { ...incoming.headers, host: target.host };
+    for (const key of ["proxy-authorization", "proxy-connection", "connection", "upgrade"])
+      delete headers[key];
+    const outgoing = httpRequest(
+      target,
+      { method: incoming.method, headers, agent: false },
+      (upstream) => {
+        response.writeHead(upstream.statusCode ?? 502, upstream.headers);
+        let bytes2 = 0;
+        upstream.on("data", (chunk) => {
+          bytes2 += chunk.length;
+          if (bytes2 > 2 * 1024 * 1024) {
+            outgoing.destroy();
+            response.destroy();
+          }
+        });
+        upstream.pipe(response);
+      }
+    );
+    pending.add(outgoing);
+    const timer = setTimeout(() => {
+      outgoing.destroy();
+      response.destroy();
+    }, 3e3);
+    outgoing.on("close", () => {
+      clearTimeout(timer);
+      pending.delete(outgoing);
+    });
+    outgoing.on("error", () => {
+      if (!response.headersSent) response.writeHead(502);
+      response.end();
+    });
+    incoming.on("aborted", () => outgoing.destroy());
+    response.on("close", () => outgoing.destroy());
+    let bytes = 0;
+    incoming.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > 1024 * 1024) {
+        outgoing.destroy();
+        incoming.destroy();
+      }
+    });
+    incoming.pipe(outgoing);
+  });
+  server.on("connect", (_, socket) => socket.destroy());
+  server.on("upgrade", (_, socket) => socket.destroy());
+  server.requestTimeout = server.headersTimeout = 3e3;
+  server.maxConnections = 64;
+  server.maxRequestsPerSocket = 100;
+  try {
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", resolve);
+    });
+  } catch {
+    server.close();
+    throw new BrowserLifecycleError("FIXTURE_PROXY_UNAVAILABLE");
+  }
+  const address = server.address();
+  if (!address || typeof address === "string")
+    throw new BrowserLifecycleError("FIXTURE_PROXY_UNAVAILABLE");
+  return {
+    url: `http://127.0.0.1:${address.port}`,
+    close: () => new Promise((resolve, reject) => {
+      for (const request of pending) request.destroy();
+      server.closeAllConnections();
+      server.close(
+        (error) => error ? reject(new BrowserLifecycleError("FIXTURE_PROXY_CLOSE_FAILED")) : resolve()
+      );
+    })
+  };
+}
+
+// packages/browser/src/runtime/darwin-owned-child.ts
+import { spawn as spawn2 } from "node:child_process";
+
+// packages/browser/src/lifecycle/process-journal.ts
+import { constants as constants2 } from "node:fs";
+import { z } from "zod";
+var JOURNAL_LIMITS = Object.freeze({
+  bytes: 1048576,
+  writerBytes: 4096,
+  identities: 512,
+  gaps: 32,
+  depth: 16,
+  pending: 8
+});
+var GAP_CODES = [
+  "boot-unknown",
+  "boot-changed",
+  "identity-unknown",
+  "root-pending",
+  "parent-changed",
+  "association-missing",
+  "observer-lost",
+  "sequence-gap",
+  "frame-invalid",
+  "capacity-exceeded",
+  "read-uncertain",
+  "persistence-uncertain",
+  "custody-pending"
+];
+var counter = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var text = (cap) => z.string().min(1).refine(
+  (v) => v.length <= cap && Buffer.byteLength(v) <= cap && Buffer.from(v).toString("utf8") === v && ![...v].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)
+);
+var opaque = text(64).refine((v) => /^[A-Za-z0-9_-]+$/.test(v));
+var digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
+var ProcessIdentitySchema = z.object({ pid: counter.refine((v) => v > 0), birth: text(128) }).strict();
+var BootScopeSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("observed"), value: text(128), sourceIdentityDigest: digestSchema }).strict(),
+  z.object({ kind: z.literal("unknown"), cause: z.enum(GAP_CODES) }).strict()
+]);
+var JournalBindingSchema = z.object({
+  journalId: opaque,
+  browserId: opaque,
+  profile: z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("persistent"), profileId: opaque }).strict(),
+    z.object({ kind: z.literal("ephemeral") }).strict()
+  ]),
+  browserGeneration: counter,
+  reservationNonce: opaque,
+  runtimeIdentityDigest: digestSchema,
+  manager: ProcessIdentitySchema,
+  bootScope: BootScopeSchema
+}).strict();
+var JournalWriterSchema = z.object({ writerId: opaque, epoch: counter, kind: z.enum(["manager", "observer", "reconciler"]) }).strict();
+var ObservationWindowSchema = z.object({
+  startSequence: counter,
+  checkpointSequence: counter,
+  endSequence: counter,
+  startMonotonic: z.number().finite().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  endMonotonic: z.number().finite().nonnegative().max(Number.MAX_SAFE_INTEGER)
+}).strict().refine(
+  (w) => w.startSequence <= w.checkpointSequence && w.checkpointSequence <= w.endSequence && w.startMonotonic <= w.endMonotonic
+);
+var AssociationSchema = z.object({
+  parentBefore: ProcessIdentitySchema,
+  parentAfter: ProcessIdentitySchema,
+  child: ProcessIdentitySchema,
+  childParentPid: counter.refine((v) => v > 0),
+  window: ObservationWindowSchema,
+  recordedSequence: counter,
+  parentDeathSequence: counter.nullable()
+}).strict().refine(
+  (a) => sameProcess(a.parentBefore, a.parentAfter) && a.child.pid !== a.parentBefore.pid && a.childParentPid === a.parentBefore.pid && a.window.endSequence <= a.recordedSequence && (a.parentDeathSequence === null || a.recordedSequence < a.parentDeathSequence)
+);
+var retainedSchema = z.object({
+  identity: ProcessIdentitySchema,
+  role: z.enum(["manager", "root", "descendant"]),
+  parent: ProcessIdentitySchema.nullable(),
+  association: AssociationSchema.nullable(),
+  currentParent: ProcessIdentitySchema.nullable(),
+  acquisitionEpoch: counter,
+  firstSeenSequence: counter,
+  lastSeenSequence: counter,
+  relationWindow: ObservationWindowSchema,
+  lifecycle: z.enum(["alive", "exited-unreaped", "dead", "replacement", "unknown"])
+}).strict();
+var gapSchema = z.object({
+  cause: z.enum(GAP_CODES),
+  firstSequence: counter,
+  identity: ProcessIdentitySchema.nullable(),
+  count: counter.refine((v) => v > 0)
+}).strict();
+var causeSchema = z.object({ cause: z.enum(GAP_CODES), sequence: counter }).strict();
+var JournalSnapshotSchema = z.object({
+  schemaVersion: z.literal(1),
+  kind: z.literal("browser-process-journal"),
+  provenance: z.literal("recorded-data"),
+  binding: JournalBindingSchema,
+  writer: JournalWriterSchema,
+  sequence: counter,
+  phase: z.enum([
+    "allocated",
+    "launch-intent",
+    "observing",
+    "manager-lost",
+    "reconciling",
+    "observation-ended",
+    "retained"
+  ]),
+  observationWindow: ObservationWindowSchema,
+  root: z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("pending") }).strict(),
+    z.object({ kind: z.literal("absent-before-launch") }).strict(),
+    z.object({
+      kind: z.literal("attributed"),
+      identity: ProcessIdentitySchema,
+      association: AssociationSchema
+    }).strict()
+  ]),
+  retainedIdentities: z.array(retainedSchema).max(JOURNAL_LIMITS.identities),
+  gaps: z.array(gapSchema).max(JOURNAL_LIMITS.gaps),
+  firstCause: causeSchema.nullable()
+}).strict();
+function sameProcess(a, b) {
+  return a.pid === b.pid && a.birth === b.birth;
+}
+var readFlags = constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK;
+var createFlags = constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW | constants2.O_NONBLOCK;
+
+// packages/browser/src/runtime/darwin-process-observer.ts
+import { createHash as createHash2 } from "node:crypto";
+import { constants as constants3 } from "node:fs";
+import { open as open2, realpath as realpath2, lstat as lstat2 } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { z as z2 } from "zod";
+var decimal = z2.string().regex(/^(0|[1-9][0-9]{0,19})$/).refine(
+  (value) => /^(0|[1-9][0-9]{0,19})$/.test(value) && BigInt(value) <= 18446744073709551615n
+);
+var identity = z2.object({
+  pid: z2.number().int().positive().max(2147483647),
+  seconds: decimal,
+  microseconds: decimal
+}).strict();
+var replySchema = z2.object({
+  version: z2.literal(1),
+  bootSeconds: decimal,
+  bootMicroseconds: decimal,
+  processes: z2.array(
+    z2.discriminatedUnion("kind", [
+      z2.object({
+        kind: z2.literal("present"),
+        identity,
+        parentPid: z2.number().int().nonnegative().max(2147483647),
+        zombie: z2.boolean()
+      }).strict(),
+      z2.object({ kind: z2.literal("absent"), pid: z2.number().int().positive().max(2147483647) }).strict(),
+      z2.object({
+        kind: z2.literal("unknown"),
+        pid: z2.number().int().positive().max(2147483647),
+        error: z2.number().int()
+      }).strict()
+    ])
+  ).max(512)
+}).strict();
+var childrenSchema = replySchema.extend({
+  parentBefore: identity.nullable(),
+  parentAfter: identity.nullable(),
+  complete: z2.boolean()
+}).strict();
+function parseDarwinChildrenBatch(bytes, parent) {
+  if (bytes.byteLength > 256 * 1024) throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+  const batch = childrenSchema.parse(
+    JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes))
+  );
+  if (BigInt(batch.bootMicroseconds) >= 1000000n)
+    throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+  const pids = /* @__PURE__ */ new Set();
+  for (const fact of batch.processes) {
+    const pid = fact.kind === "present" ? fact.identity.pid : fact.pid;
+    if (pids.has(pid)) throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+    pids.add(pid);
+    if (fact.kind === "present") darwinBirth(fact.identity);
+  }
+  if (batch.complete && (!batch.parentBefore || !batch.parentAfter || darwinBirth(batch.parentBefore).birth !== parent.birth || batch.parentBefore.pid !== parent.pid || darwinBirth(batch.parentAfter).birth !== parent.birth || batch.parentAfter.pid !== parent.pid || batch.processes.some(
+    (fact) => fact.kind !== "present" || fact.parentPid !== parent.pid || fact.identity.pid === parent.pid
+  )))
+    throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+  return batch;
+}
+function darwinBirth(value) {
+  if (BigInt(value.microseconds) >= 1000000n) throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+  return Object.freeze({
+    pid: value.pid,
+    birth: `darwin-bsd-start:${value.seconds}:${value.microseconds}`
+  });
+}
+function parseDarwinProcessBatch(bytes, requested) {
+  if (bytes.byteLength > 256 * 1024) throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+  const batch = replySchema.parse(
+    JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes))
+  );
+  if (BigInt(batch.bootMicroseconds) >= 1000000n || batch.processes.length !== requested.length)
+    throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+  const remaining = new Set(requested);
+  for (const fact of batch.processes) {
+    const pid = fact.kind === "present" ? fact.identity.pid : fact.pid;
+    if (!remaining.delete(pid)) throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+    if (fact.kind === "present") darwinBirth(fact.identity);
+  }
+  if (remaining.size) throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+  return batch;
+}
+var heldReads = /* @__PURE__ */ new Set();
+var heldChildren = /* @__PURE__ */ new Set();
+var readCustodyUncertain = false;
+function createDarwinProcessObserver(artifact) {
+  const descriptor = Object.freeze({ ...artifact });
+  const invoke = async (command, pids) => {
+    if (readCustodyUncertain || process.platform !== "darwin" || !/^[a-f0-9]{64}$/.test(descriptor.sha256) || pids.length < 1 || pids.length > 512 || new Set(pids).size !== pids.length || pids.some((pid) => !Number.isSafeInteger(pid) || pid < 1 || pid > 2147483647))
+      throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+    if (await realpath2(descriptor.path) !== descriptor.path)
+      throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+    const file = await open2(
+      descriptor.path,
+      constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK
+    );
+    heldReads.add(file);
+    let primary, failed = false;
+    try {
+      const before = await file.stat({ bigint: true });
+      if (!before.isFile() || before.size > 4n * 1024n * 1024n || (before.mode & 0o111n) === 0n)
+        throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+      const hash = createHash2("sha256");
+      const buffer = new Uint8Array(65536);
+      let bytes = 0;
+      for (; ; ) {
+        const read = await file.read(
+          buffer,
+          0,
+          Math.min(buffer.length, 4 * 1024 * 1024 + 1 - bytes),
+          null
+        );
+        if (!read.bytesRead) break;
+        bytes += read.bytesRead;
+        if (bytes > 4 * 1024 * 1024) throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+        hash.update(buffer.subarray(0, read.bytesRead));
+      }
+      const after = await file.stat({ bigint: true });
+      const named = await lstat2(descriptor.path, { bigint: true });
+      if (!named.isFile() || named.dev !== after.dev || named.ino !== after.ino)
+        throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+      if (hash.digest("hex") !== descriptor.sha256 || before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs)
+        throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+    } catch (error) {
+      primary = error;
+      failed = true;
+    }
+    try {
+      await file.close();
+      heldReads.delete(file);
+    } catch (error) {
+      readCustodyUncertain = true;
+      if (!failed) primary = error;
+      failed = true;
+    }
+    if (failed) throw primary;
+    if (readCustodyUncertain) throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+    const child = spawn(descriptor.path, [command, ...pids.map(String)], {
+      shell: false,
+      detached: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { PATH: "/usr/bin:/bin", LANG: "C", LC_ALL: "C" }
+    });
+    heldChildren.add(child);
+    let failedChild = false;
+    const terminal = new Promise((done) => {
+      child.on("error", () => {
+        failedChild = true;
+      });
+      child.once("close", (code2) => done(code2));
+    });
+    const pipeReturns = [
+      { eof: false, closed: false },
+      { eof: false, closed: false }
+    ];
+    const drain = async (stream, duty) => {
+      if (!stream) {
+        failedChild = true;
+        return new Uint8Array();
+      }
+      stream.once("end", () => {
+        duty.eof = true;
+      });
+      stream.once("close", () => {
+        duty.closed = true;
+      });
+      const chunks = [];
+      let bytes = 0;
+      for await (const value of stream) {
+        const chunk = Buffer.from(value);
+        bytes += chunk.length;
+        if (bytes <= 256 * 1024) chunks.push(chunk);
+        else failedChild = true;
+      }
+      if (!stream.readableEnded || !duty.eof) throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+      return Buffer.concat(chunks);
+    };
+    const streams = await Promise.allSettled([
+      drain(child.stdout, pipeReturns[0]),
+      drain(child.stderr, pipeReturns[1])
+    ]);
+    const code = await terminal;
+    const pipesReturned = streams.every((stream) => stream.status === "fulfilled") && pipeReturns.every((duty) => duty.eof && duty.closed);
+    if (pipesReturned) heldChildren.delete(child);
+    else readCustodyUncertain = true;
+    if (readCustodyUncertain || failedChild || code !== 0 || !pipesReturned)
+      throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+    const stdout = streams[0];
+    if (stdout.status !== "fulfilled") throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+    return stdout.value;
+  };
+  return Object.freeze({
+    async inspect(pids) {
+      return parseDarwinProcessBatch(await invoke("inspect", pids), pids);
+    },
+    async children(parent) {
+      return parseDarwinChildrenBatch(await invoke("children", [parent.pid]), parent);
+    }
+  });
+}
+
+// packages/browser/src/runtime/darwin-owned-child.ts
+var returnBrand = /* @__PURE__ */ Symbol("Darwin original child return");
+var ownership = /* @__PURE__ */ new WeakMap();
+var returns = /* @__PURE__ */ new WeakMap();
+var retained2 = /* @__PURE__ */ new Set();
+function acceptsDarwinOwnedChildReturn(child, returned) {
+  return !!returned && typeof returned === "object" && ownership.has(child) && returns.get(returned) === ownership.get(child);
+}
+function createDarwinOwnedChildLauncher(options) {
+  const observer = createDarwinProcessObserver(options.artifact);
+  const manager = Object.freeze({ ...options.manager });
+  return Object.freeze({
+    async launch(command) {
+      if (process.platform !== "darwin" || process.pid === manager.pid)
+        throw new Error("SUPERVISOR_PROCESS_REQUIRED");
+      const initial = await observer.inspect([process.pid, manager.pid]);
+      const supervisor = initial.processes.find(
+        (fact) => fact.kind === "present" && fact.identity.pid === process.pid
+      );
+      const observedManager = initial.processes.find(
+        (fact) => fact.kind === "present" && fact.identity.pid === manager.pid
+      );
+      if (!supervisor || supervisor.kind !== "present" || supervisor.zombie || !observedManager || observedManager.kind !== "present" || observedManager.zombie || !sameProcess(darwinBirth(observedManager.identity), manager))
+        throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+      const boot = `${initial.bootSeconds}:${initial.bootMicroseconds}`;
+      const state = { child: null, pending: true, firstCause: null };
+      retained2.add(state);
+      const fail = (cause) => {
+        state.firstCause ??= cause;
+      };
+      let child;
+      try {
+        child = spawn2(command.executable, [...command.argv], {
+          cwd: command.cwd,
+          env: { ...command.env },
+          shell: false,
+          detached: false,
+          stdio: command.ipc ? ["ignore", "pipe", "pipe", "ipc"] : ["ignore", "pipe", "pipe"]
+        });
+        state.child = child;
+      } catch (error) {
+        fail("CHILD_ACQUISITION_UNCERTAIN");
+        throw error;
+      }
+      let exitObserved = false, closeObserved = false;
+      let exitCode = null, signal = null;
+      const terminal = new Promise((resolve) => {
+        child.on("error", () => fail("CHILD_ERROR"));
+        child.once("exit", (code, killedBy) => {
+          exitObserved = true;
+          exitCode = code;
+          signal = killedBy;
+          if (killedBy) fail("CHILD_SIGNALED");
+          else if (code !== 0) fail("CHILD_EXIT_FAILED");
+        });
+        child.once("close", (code, killedBy) => {
+          closeObserved = true;
+          if (!exitObserved || code !== exitCode || killedBy !== signal)
+            fail("CHILD_TERMINAL_UNCERTAIN");
+          resolve();
+        });
+      });
+      const drain = (original) => {
+        let eof = false, closed = false, overflow = false;
+        const chunks = [];
+        let retainedBytes = 0;
+        const completion2 = new Promise((resolve) => {
+          if (!original) {
+            fail("CHILD_PIPE_UNAVAILABLE");
+            resolve(new Uint8Array());
+            return;
+          }
+          original.once("end", () => {
+            eof = true;
+          });
+          original.on("error", () => fail("CHILD_PIPE_ERROR"));
+          original.once("close", () => {
+            closed = true;
+            if (!eof) fail("CHILD_PIPE_EOF_UNAVAILABLE");
+            try {
+              resolve(Buffer.concat(chunks));
+            } catch {
+              fail("CHILD_PIPE_RETENTION_UNAVAILABLE");
+              resolve(new Uint8Array());
+            }
+          });
+          original.on("data", (value) => {
+            if (overflow) return;
+            if (value.byteLength > 256 * 1024 - retainedBytes) {
+              overflow = true;
+              fail("CHILD_PIPE_OVERFLOW");
+              return;
+            }
+            try {
+              const copy = Uint8Array.from(value);
+              retainedBytes += copy.byteLength;
+              chunks.push(copy);
+            } catch {
+              overflow = true;
+              fail("CHILD_PIPE_RETENTION_UNAVAILABLE");
+            }
+          });
+        });
+        return { completion: completion2, complete: () => eof && closed };
+      };
+      const stdout = drain(child.stdout), stderr = drain(child.stderr);
+      const identity3 = (async () => {
+        if (!child.pid) throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+        const batch = await observer.inspect([process.pid, child.pid]);
+        const parent = batch.processes.find(
+          (fact2) => fact2.kind === "present" && fact2.identity.pid === process.pid
+        );
+        const fact = batch.processes.find(
+          (fact2) => fact2.kind === "present" && fact2.identity.pid === child.pid
+        );
+        if (`${batch.bootSeconds}:${batch.bootMicroseconds}` !== boot || !parent || parent.kind !== "present" || parent.zombie || !sameProcess(darwinBirth(parent.identity), darwinBirth(supervisor.identity)) || !fact || fact.kind !== "present" || fact.zombie || fact.parentPid !== process.pid)
+          throw new Error("PROCESS_OBSERVATION_UNAVAILABLE");
+        return Object.freeze(darwinBirth(fact.identity));
+      })();
+      void identity3.catch(() => fail("CHILD_BIRTH_UNAVAILABLE"));
+      let token = null;
+      const completion = (async () => {
+        const [out, err] = await Promise.all([stdout.completion, stderr.completion, terminal]);
+        let birth = null;
+        try {
+          birth = await identity3;
+        } catch {
+          fail("CHILD_BIRTH_UNAVAILABLE");
+        }
+        if (!exitObserved || !closeObserved || !stdout.complete() || !stderr.complete())
+          fail("CHILD_RETURN_UNCERTAIN");
+        if (birth) {
+          try {
+            const batch = await observer.inspect([birth.pid]);
+            if (`${batch.bootSeconds}:${batch.bootMicroseconds}` !== boot || batch.processes[0]?.kind !== "absent")
+              fail("CHILD_NATIVE_RETURN_UNAVAILABLE");
+          } catch {
+            fail("CHILD_NATIVE_RETURN_UNAVAILABLE");
+          }
+        }
+        if (state.firstCause === null && birth) {
+          token = Object.freeze({ [returnBrand]: true });
+          returns.set(token, state);
+          state.pending = false;
+          retained2.delete(state);
+        }
+        return Object.freeze({
+          exitCode,
+          signal,
+          firstCause: state.firstCause,
+          stdout: out,
+          stderr: err
+        });
+      })();
+      const handle = Object.freeze({
+        child,
+        identity: () => identity3,
+        completion: () => completion,
+        returned: async () => {
+          await completion;
+          return token;
+        },
+        custody: () => Object.freeze({ pending: state.pending, firstCause: state.firstCause })
+      });
+      ownership.set(handle, state);
+      return handle;
+    }
+  });
+}
+
+// packages/browser/src/runtime/host-identity.ts
+import { readlinkSync } from "node:fs";
+import { hostname } from "node:os";
+import { join as join2 } from "node:path";
+function nativeHolderPid(profileDir) {
+  let target;
+  try {
+    target = readlinkSync(join2(profileDir, "SingletonLock"));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw new BrowserLifecycleError("UNKNOWN_NATIVE_HOLDER");
+  }
+  const match = /^(.*)-(\d+)$/.exec(target);
+  if (!match || match[1] !== hostname()) throw new BrowserLifecycleError("UNKNOWN_NATIVE_HOLDER");
+  const pid = Number(match[2]);
+  if (!Number.isSafeInteger(pid) || pid < 1 || pid > 2147483647)
+    throw new BrowserLifecycleError("UNKNOWN_NATIVE_HOLDER");
+  return pid;
+}
+
+// packages/browser/src/runtime/darwin-engine-processes.ts
+function createDarwinEngineProcesses(artifact) {
+  const observer = createDarwinProcessObserver(artifact);
+  let boot;
+  const checkBoot = (batch) => {
+    const value = `${batch.bootSeconds}:${batch.bootMicroseconds}`;
+    if (boot !== void 0 && boot !== value) throw new Error("BOOT_CHANGED");
+    boot = value;
+  };
+  const identity3 = async (pid) => {
+    const batch = await observer.inspect([pid]);
+    checkBoot(batch);
+    const fact = batch.processes[0];
+    if (fact?.kind === "absent") return null;
+    if (fact?.kind !== "present" || fact.zombie)
+      throw new BrowserLifecycleError("PROCESS_OBSERVATION_UNAVAILABLE");
+    return darwinBirth(fact.identity);
+  };
+  const processes = {
+    async observe(original, signal) {
+      if (signal.aborted) return { status: "unknown" };
+      try {
+        const batch = await observer.inspect([original.pid]);
+        checkBoot(batch);
+        if (signal.aborted) return { status: "unknown" };
+        const fact = batch.processes[0];
+        if (fact?.kind === "absent") return { status: "dead" };
+        if (fact?.kind !== "present" || fact.zombie) return { status: "unknown" };
+        return { status: sameProcess(darwinBirth(fact.identity), original) ? "alive" : "dead" };
+      } catch {
+        return { status: "unknown" };
+      }
+    },
+    async descendants(original, signal) {
+      try {
+        const identities = [original];
+        const pids = /* @__PURE__ */ new Set([original.pid]);
+        for (let index = 0; index < identities.length; index++) {
+          if (signal.aborted || !observer.children) throw new Error();
+          const parent = identities[index];
+          const batch = await observer.children(parent);
+          checkBoot(batch);
+          if (!batch.complete || signal.aborted) throw new Error();
+          for (const fact of batch.processes) {
+            if (fact.kind !== "present" || fact.zombie || fact.parentPid !== parent.pid || pids.has(fact.identity.pid))
+              throw new Error();
+            if (identities.length >= 512) throw new Error();
+            pids.add(fact.identity.pid);
+            identities.push(darwinBirth(fact.identity));
+          }
+        }
+        return { status: "complete", identities };
+      } catch {
+        return { status: "unknown", identities: [] };
+      }
+    }
+  };
+  return Object.freeze({
+    identity: identity3,
+    processes,
+    /** Only for terminal descendants after original root-child/pipe return; never recovery. */
+    async observeTerminated(original, signal) {
+      if (signal.aborted) return { status: "unknown" };
+      try {
+        const batch = await observer.inspect([original.pid]);
+        checkBoot(batch);
+        if (signal.aborted) return { status: "unknown" };
+        const fact = batch.processes[0];
+        if (fact?.kind === "absent") return { status: "dead" };
+        if (fact?.kind !== "present") return { status: "unknown" };
+        if (!sameProcess(darwinBirth(fact.identity), original) || fact.zombie)
+          return { status: "dead" };
+        return { status: "alive" };
+      } catch {
+        return { status: "unknown" };
+      }
+    },
+    async attributeRoot(manager, root) {
+      if (manager.pid === root.pid) return false;
+      const before = await observer.inspect([manager.pid, root.pid]);
+      checkBoot(before);
+      const parent = before.processes.find(
+        (fact) => fact.kind === "present" && fact.identity.pid === manager.pid
+      );
+      const child = before.processes.find(
+        (fact) => fact.kind === "present" && fact.identity.pid === root.pid
+      );
+      const after = await observer.inspect([manager.pid]);
+      checkBoot(after);
+      const repeated = after.processes[0];
+      return parent?.kind === "present" && !parent.zombie && sameProcess(darwinBirth(parent.identity), manager) && child?.kind === "present" && !child.zombie && child.parentPid === manager.pid && sameProcess(darwinBirth(child.identity), root) && repeated?.kind === "present" && !repeated.zombie && sameProcess(darwinBirth(repeated.identity), manager);
+    },
+    async holder(profileDir) {
+      const pid = nativeHolderPid(profileDir);
+      if (pid === null) return null;
+      const result = await identity3(pid);
+      if (!result) throw new BrowserLifecycleError("UNKNOWN_NATIVE_HOLDER");
+      return result;
+    }
+  });
+}
+
+// packages/browser/src/profiles/owned-directory.ts
+import { lstatSync, realpathSync } from "node:fs";
+function ownDirectory(path) {
+  const entry = lstatSync(path);
+  if (!entry.isDirectory() || entry.isSymbolicLink() || realpathSync(path) !== path || (entry.mode & 63) !== 0 || process.getuid && entry.uid !== process.getuid())
+    throw new BrowserLifecycleError("PROFILE_UNCERTAIN");
+  return Object.freeze({ path, dev: entry.dev, ino: entry.ino });
+}
+function assertDirectory(owner) {
+  let current;
+  try {
+    current = ownDirectory(owner.path);
+  } catch {
+    throw new BrowserLifecycleError("PROFILE_UNCERTAIN");
+  }
+  if (current.dev !== owner.dev || current.ino !== owner.ino)
+    throw new BrowserLifecycleError("PROFILE_UNCERTAIN");
+}
+
+// packages/browser/src/runtime/darwin-supervisor-browser.ts
+var retained3 = /* @__PURE__ */ new Set();
+var endpointReads = /* @__PURE__ */ new Set();
+var endpointUncertain = false;
+async function waitWithin(original, milliseconds) {
+  let timer;
+  try {
+    return await Promise.race([
+      original,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error("SUPERVISOR_WAIT_EXPIRED")), milliseconds);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function parseOwnedDevToolsEndpoint(bytes) {
+  if (bytes.byteLength > 1024) throw new Error("DEVTOOLS_ENDPOINT_UNAVAILABLE");
+  const value = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  const match = /^([1-9][0-9]{0,4})\n(\/devtools\/browser\/[a-fA-F0-9-]{36})\n?$/.exec(value);
+  if (!match || Number(match[1]) > 65535) throw new Error("DEVTOOLS_ENDPOINT_UNAVAILABLE");
+  return `ws://127.0.0.1:${match[1]}${match[2]}`;
+}
+async function endpoint(file, before, directory) {
+  assertDirectory(directory);
+  const original = await open3(
+    file,
+    constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK
+  );
+  endpointReads.add(original);
+  let failed = false, primary, result = "";
+  try {
+    const first = await original.stat({ bigint: true });
+    if (!first.isFile() || first.size > 1024n || first.uid !== BigInt(process.getuid()))
+      throw new Error("DEVTOOLS_ENDPOINT_UNAVAILABLE");
+    const fingerprint = `${first.dev}:${first.ino}:${first.size}:${first.mtimeNs}:${first.ctimeNs}`;
+    if (fingerprint === before) throw new Error("DEVTOOLS_ENDPOINT_STALE");
+    const bytes = new Uint8Array(1025);
+    const read = await original.read(bytes, 0, bytes.length, 0);
+    const after = await original.stat({ bigint: true }), named = await lstat3(file, { bigint: true });
+    for (const stat2 of [after, named])
+      if (!stat2.isFile() || stat2.dev !== first.dev || stat2.ino !== first.ino || stat2.size !== first.size || stat2.mtimeNs !== first.mtimeNs || stat2.ctimeNs !== first.ctimeNs)
+        throw new Error("DEVTOOLS_ENDPOINT_CHANGED");
+    if (read.bytesRead !== Number(first.size)) throw new Error("DEVTOOLS_ENDPOINT_UNAVAILABLE");
+    assertDirectory(directory);
+    result = parseOwnedDevToolsEndpoint(bytes.subarray(0, read.bytesRead));
+  } catch (error) {
+    failed = true;
+    primary = error;
+  }
+  try {
+    await original.close();
+    endpointReads.delete(original);
+  } catch (error) {
+    endpointUncertain = true;
+    throw Object.assign(new Error("DEVTOOLS_CLOSE_UNCERTAIN", { cause: error }), {
+      primaryReadFailure: failed ? primary : null
+    });
+  }
+  if (failed) throw primary;
+  return result;
+}
+async function launchDarwinSupervisorBrowser(options, failed = () => {
+}, originalRootReturned) {
+  if (endpointUncertain) throw new Error("DEVTOOLS_CLOSE_UNCERTAIN");
+  const directory = ownDirectory(options.profileDir);
+  for (const original of retained3)
+    if (original.directory.path === directory.path || original.directory.dev === directory.dev && original.directory.ino === directory.ino)
+      throw new Error("SUPERVISOR_PROFILE_UNCERTAIN");
+  const state = { directory, uncertain: false };
+  retained3.add(state);
+  const processes = createDarwinEngineProcesses(options.artifact);
+  const file = join3(options.profileDir, "DevToolsActivePort");
+  let before = null;
+  let root;
+  let supervisor;
+  let endpointURL;
+  try {
+    const chromium = await verifiedLibrary(options.runtime);
+    try {
+      const stat2 = await lstat3(file, { bigint: true });
+      if (!stat2.isFile() || stat2.size > 1024n || stat2.uid !== BigInt(process.getuid()))
+        throw new Error("DEVTOOLS_ENDPOINT_UNAVAILABLE");
+      before = `${stat2.dev}:${stat2.ino}:${stat2.size}:${stat2.mtimeNs}:${stat2.ctimeNs}`;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (!options.ownedProxy) state.proxy = await startFixtureProxy(options.origin);
+    assertDirectory(directory);
+    state.child = await createDarwinOwnedChildLauncher({
+      artifact: options.artifact,
+      manager: options.manager
+    }).launch({
+      executable: options.runtime.executable.path,
+      cwd: options.profileDir,
+      env: { PATH: "/usr/bin:/bin", HOME: options.profileDir, LANG: "C", LC_ALL: "C" },
+      argv: [
+        "--headless=new",
+        "--remote-debugging-address=127.0.0.1",
+        "--remote-debugging-port=0",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-background-networking",
+        // Match relevant public launch defaults of the verified pinned library.
+        "--disable-features=AvoidUnnecessaryBeforeUnloadCheckSync,DestroyProfileOnBrowserClose,DialMediaRouteProvider,GlobalMediaControls,HttpsUpgrades,LensOverlay,MediaRouter,PaintHolding,ThirdPartyStoragePartitioning,BlockOriginHeaderModificationOnRedirect,Translate,AutoDeElevate,OptimizationHints",
+        "--disable-field-trial-config",
+        "--disable-background-timer-throttling",
+        "--disable-backgrounding-occluded-windows",
+        "--disable-back-forward-cache",
+        "--disable-breakpad",
+        "--disable-client-side-phishing-detection",
+        "--disable-component-extensions-with-background-pages",
+        "--disable-component-update",
+        "--disable-default-apps",
+        "--disable-dev-shm-usage",
+        "--disable-extensions",
+        "--disable-hang-monitor",
+        "--disable-renderer-backgrounding",
+        "--disable-sync",
+        "--no-service-autorun",
+        "--metrics-recording-only",
+        "--force-color-profile=srgb",
+        "--password-store=basic",
+        "--use-mock-keychain",
+        `--user-data-dir=${options.profileDir}`,
+        `--proxy-server=${options.ownedProxy?.url ?? state.proxy.url}`,
+        "--proxy-bypass-list=<-loopback>",
+        "--disable-quic",
+        "--webrtc-ip-handling-policy=disable_non_proxied_udp",
+        "about:blank"
+      ]
+    });
+    root = await state.child.identity();
+    const originalRoot = root;
+    state.child.child.once("exit", (code, signal) => {
+      if (code !== 0 || signal !== null) {
+        state.uncertain = true;
+        failed("browser", originalRoot);
+      }
+    });
+    const end = performance.now() + 1e4;
+    let url;
+    while (performance.now() < end) {
+      try {
+        url = await endpoint(file, before, directory);
+        break;
+      } catch (error) {
+        if (error instanceof Error && error.message === "DEVTOOLS_CLOSE_UNCERTAIN") throw error;
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+    }
+    if (!url) throw new Error("DEVTOOLS_ENDPOINT_UNAVAILABLE");
+    endpointURL = url;
+    const holder = await processes.holder(options.profileDir);
+    assertDirectory(directory);
+    if (!holder || !sameProcess(holder, root)) throw new Error("DEVTOOLS_ROOT_MISMATCH");
+    const sender = await processes.identity(process.pid);
+    if (!sender) throw new Error("SUPERVISOR_IDENTITY_UNAVAILABLE");
+    supervisor = sender;
+    if (options.ownedProxy)
+      state.auth = await ownPrivateProxyAuthentication(url, options.ownedProxy, () => {
+        state.uncertain = true;
+        failed("custody");
+      });
+    state.browser = await chromium.connectOverCDP(url, {
+      timeout: Math.max(1, end - performance.now()),
+      noDefaults: true
+    });
+    state.downloads = new DefaultDownloadOwner(
+      state.browser,
+      () => !state.uncertain && performance.now() < end,
+      () => {
+        state.uncertain = true;
+        failed("custody");
+      }
+    );
+    await waitWithin(state.downloads.ready, Math.max(1, end - performance.now()));
+    if (state.browser.contexts().length !== 1) throw new Error("PERSISTENT_CONTEXT_UNAVAILABLE");
+  } catch (error) {
+    state.uncertain = true;
+    state.downloads?.retire();
+    try {
+      state.child?.child.kill("SIGTERM");
+    } catch {
+    }
+    state.cleanup = Promise.allSettled([
+      // Join initialization even if the independent original browser closure refuses.
+      state.downloads?.ready,
+      Promise.resolve().then(() => closeBrowserAndDownloads(state.browser, state.downloads)),
+      Promise.resolve().then(() => state.proxy?.close()),
+      Promise.resolve().then(() => state.auth?.close()),
+      Promise.resolve().then(() => state.child?.completion())
+    ]);
+    await waitWithin(state.cleanup, 2e3).catch(() => {
+    });
+    throw error;
+  }
+  const browser = state.browser, child = state.child, proxy = state.proxy;
+  const context = browser.contexts()[0];
+  let closing;
+  return Object.freeze({
+    context,
+    root,
+    child,
+    supervisor,
+    proxyURL: options.ownedProxy?.url ?? proxy.url,
+    endpointURL,
+    close() {
+      if (closing) return closing;
+      state.downloads?.retire();
+      const original = (async () => {
+        const abort = new AbortController();
+        let tree = { status: "unknown", identities: [] };
+        try {
+          tree = await processes.processes.descendants(root, abort.signal);
+        } catch {
+          state.uncertain = true;
+        }
+        if (tree.status !== "complete") state.uncertain = true;
+        const results = await Promise.allSettled([
+          (async () => {
+            const session = await browser.newBrowserCDPSession();
+            await session.send("Browser.close");
+          })(),
+          Promise.resolve().then(() => proxy?.close()),
+          Promise.resolve().then(() => state.auth?.close())
+        ]);
+        for (const result of results)
+          if (result.status === "rejected")
+            process.stderr.write(
+              "SUPERVISOR_CLOSE: " + String(
+                result.reason instanceof Error ? result.reason.message.slice(0, 1024) : "unknown"
+              ) + "\n"
+            );
+        if (results.some((result) => result.status === "rejected")) state.uncertain = true;
+        const returned = await child.returned();
+        const rootReturnForward = returned && acceptsDarwinOwnedChildReturn(child, returned) && originalRootReturned ? Promise.resolve().then(() => originalRootReturned(Object.freeze({ ...root }))) : Promise.resolve();
+        void rootReturnForward.catch(() => {
+        });
+        if (!returned)
+          process.stderr.write(
+            "SUPERVISOR_CHILD_RETURN: " + String(child.custody().firstCause) + "\n"
+          );
+        let statuses = [];
+        const nativeEnd = performance.now() + 2e3;
+        try {
+          do {
+            statuses = await Promise.all(
+              tree.identities.map((identity3) => processes.observeTerminated(identity3, abort.signal))
+            );
+            if (statuses.length && statuses.every((value) => value.status === "dead")) break;
+            await new Promise((resolve) => setTimeout(resolve, 25));
+          } while (performance.now() < nativeEnd);
+        } catch {
+          state.uncertain = true;
+        }
+        try {
+          await closeBrowserAndDownloads(browser, state.downloads);
+        } catch {
+          state.uncertain = true;
+        }
+        try {
+          await rootReturnForward;
+        } catch {
+          state.uncertain = true;
+        }
+        abort.abort();
+        if (!returned || !acceptsDarwinOwnedChildReturn(child, returned) || !statuses.length || statuses.some((value) => value.status !== "dead"))
+          state.uncertain = true;
+        if (!state.uncertain) retained3.delete(state);
+        return !state.uncertain;
+      })();
+      state.cleanup = original;
+      closing = waitWithin(original, 5e3).catch(() => {
+        state.uncertain = true;
+        return false;
+      });
+      return closing;
+    }
+  });
+}
+
+// packages/browser/src/runtime/darwin-supervisor-protocol.ts
+import { z as z5 } from "zod";
+
+// packages/browser/src/runtime-descriptor.ts
+import { isAbsolute, normalize, parse } from "node:path";
+import { z as z4 } from "zod";
+
+// packages/browser/src/counters.ts
+import { z as z3 } from "zod";
+
+// packages/browser/src/validation.ts
+var MAX_BYTES = 16 * 1024;
+
+// packages/browser/src/counters.ts
+var CounterSchema = z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+
+// packages/browser/src/runtime-descriptor.ts
+var AbsolutePathSchema = z4.string().min(1).max(4096).refine(
+  (value) => !value.includes("\0") && isAbsolute(value) && normalize(value) === value && parse(value).root !== value
+);
+var RuntimeSchema = z4.object({
+  library: z4.object({
+    package: z4.literal("playwright-core"),
+    version: z4.literal("1.63.0"),
+    rootDir: AbsolutePathSchema,
+    assets: z4.object({ manifest: z4.literal("browsers.json"), cli: z4.literal("cli.js") }).strict()
+  }).strict(),
+  executable: z4.object({
+    path: AbsolutePathSchema,
+    sha256: z4.string().regex(/^[a-f0-9]{64}$/),
+    revision: z4.string().min(1).max(16).regex(/^\d+$/),
+    version: z4.string().max(64).regex(/^\d+\.\d+\.\d+(?:\.\d+)?$/),
+    platform: z4.enum(["darwin", "linux", "win32"]),
+    arch: z4.enum(["arm64", "x64"])
+  }).strict(),
+  identity: z4.object({ mode: z4.enum(["native", "chrome-compatible"]), policyRevision: CounterSchema }).strict()
+}).strict();
+var RuntimeDescriptorSchema = RuntimeSchema;
+
+// packages/browser/src/runtime/darwin-supervisor-protocol.ts
+var counter2 = z5.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var identity2 = z5.object({ pid: z5.number().int().positive().max(2147483647), birth: z5.string().min(1).max(128) }).strict();
+var nonce = z5.string().uuid();
+var sequence = counter2.refine((value) => value > 0);
+var SupervisorSeedSchema = z5.object({
+  kind: z5.literal("launch"),
+  nonce,
+  reservationNonce: nonce,
+  manager: identity2,
+  browserId: z5.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/),
+  generation: counter2,
+  runtime: RuntimeDescriptorSchema,
+  profileDir: AbsolutePathSchema,
+  artifact: z5.object({ path: AbsolutePathSchema, sha256: z5.string().regex(/^[a-f0-9]{64}$/) }).strict(),
+  ownedProxy: z5.object({
+    url: z5.string().regex(/^http:\/\/127\.0\.0\.1:[1-9][0-9]{0,4}$/),
+    credentials: z5.object({ username: z5.literal("dorkos"), password: z5.string().min(1).max(4096) }).strict()
+  }).strict().optional(),
+  origin: z5.string().url().max(256).refine((value) => {
+    const url = new URL(value);
+    return value === "about:blank" || url.protocol === "http:" && ["127.0.0.1", "[::1]"].includes(url.hostname) && url.origin === value && !!url.port;
+  })
+}).strict();
+var SupervisorActionSchema = z5.discriminatedUnion("kind", [
+  z5.object({ kind: z5.literal("list") }).strict(),
+  z5.object({
+    kind: z5.literal("navigate"),
+    tab: sequence,
+    url: z5.string().url().max(4096).refine((value) => ["http:", "https:"].includes(new URL(value).protocol))
+  }).strict(),
+  z5.object({ kind: z5.literal("close") }).strict()
+]);
+var SupervisorCommandSchema = z5.object({ kind: z5.literal("command"), nonce, sequence, action: SupervisorActionSchema }).strict();
+var tab = z5.object({ tab: sequence, url: z5.string().max(4096) }).strict();
+var SupervisorReplySchema = z5.discriminatedUnion("kind", [
+  z5.object({
+    kind: z5.literal("ready"),
+    nonce,
+    reservationNonce: nonce,
+    browserId: SupervisorSeedSchema.shape.browserId,
+    generation: counter2,
+    endpointURL: z5.string().max(256).regex(/^ws:\/\/127\.0\.0\.1:[1-9][0-9]{0,4}\/devtools\/browser\/[a-fA-F0-9-]{36}$/),
+    root: identity2,
+    supervisor: identity2,
+    proxyURL: z5.string().max(256).regex(/^http:\/\/127\.0\.0\.1:[1-9][0-9]{0,4}$/)
+  }).strict(),
+  z5.object({
+    kind: z5.literal("reply"),
+    nonce,
+    sequence,
+    value: z5.union([z5.array(tab).max(128), z5.object({ tab: sequence }).strict()])
+  }).strict(),
+  z5.object({ kind: z5.literal("rootReturned"), nonce, sequence, root: identity2 }).strict(),
+  z5.object({ kind: z5.literal("closed"), nonce, sequence, returned: z5.boolean() }).strict(),
+  z5.object({ kind: z5.literal("refused"), nonce, sequence }).strict(),
+  z5.object({ kind: z5.literal("custodyFault"), nonce }).strict(),
+  z5.object({ kind: z5.literal("rootFailure"), nonce, root: identity2 }).strict()
+]);
+
+// packages/browser/src/runtime/darwin-supervisor-worker.ts
+async function runDarwinSupervisorWorker() {
+  let owner;
+  let launching, stopping = false, accepted = false, lastSequence = 0;
+  let seed;
+  let pending = 0, tail = Promise.resolve(), closePromise;
+  let originalCloseSequence;
+  const pages = /* @__PURE__ */ new Map();
+  let nextTab = 1;
+  const sends = /* @__PURE__ */ new Set();
+  const send = async (value) => {
+    if (!process.connected || !process.send) return;
+    const parsed = SupervisorReplySchema.parse(value);
+    if (Buffer.byteLength(JSON.stringify(value)) > 65536)
+      throw new Error("SUPERVISOR_REPLY_EXCEEDED");
+    const original = new Promise(
+      (resolve, reject) => process.send(parsed, (error) => error ? reject(error) : resolve())
+    );
+    sends.add(original);
+    void original.then(
+      () => sends.delete(original),
+      () => {
+      }
+    );
+    await original;
+  };
+  const close = () => {
+    stopping = true;
+    closePromise ??= (async () => {
+      await launching?.catch(() => {
+      });
+      const [result] = await Promise.all([owner ? owner.close() : Promise.resolve(false), tail]);
+      pages.clear();
+      return result && sends.size === 0;
+    })();
+    return closePromise;
+  };
+  const disconnect = () => {
+    void close().then(
+      (returned) => {
+        process.exitCode = returned ? 0 : 1;
+        if (process.connected) process.disconnect();
+      },
+      () => {
+        process.exitCode = 1;
+        if (process.connected) process.disconnect();
+      }
+    );
+  };
+  process.once("disconnect", disconnect);
+  process.on("message", (message) => {
+    if (stopping) return;
+    let bytes;
+    try {
+      bytes = Buffer.byteLength(JSON.stringify(message));
+    } catch {
+      disconnect();
+      return;
+    }
+    if (bytes > 65536) {
+      disconnect();
+      return;
+    }
+    if (!accepted) {
+      accepted = true;
+      const parsed2 = SupervisorSeedSchema.safeParse(message);
+      if (!parsed2.success) {
+        disconnect();
+        return;
+      }
+      seed = parsed2.data;
+      if (seed.manager.pid !== process.ppid) {
+        disconnect();
+        return;
+      }
+      const origin = new URL(seed.origin);
+      if (!seed.ownedProxy && (origin.protocol !== "http:" || !["127.0.0.1", "[::1]"].includes(origin.hostname) || origin.origin !== seed.origin || !origin.port)) {
+        disconnect();
+        return;
+      }
+      launching = (async () => {
+        owner = await launchDarwinSupervisorBrowser(
+          seed,
+          (cause, root) => {
+            void send(
+              cause === "browser" && root ? { kind: "rootFailure", nonce: seed.nonce, root } : { kind: "custodyFault", nonce: seed.nonce }
+            ).catch(() => {
+            });
+            disconnect();
+          },
+          async (root) => {
+            if (originalCloseSequence === void 0) return;
+            await send({
+              kind: "rootReturned",
+              nonce: seed.nonce,
+              sequence: originalCloseSequence,
+              root
+            });
+          }
+        );
+        if (stopping) return;
+        void send({
+          kind: "ready",
+          nonce: seed.nonce,
+          browserId: seed.browserId,
+          reservationNonce: seed.reservationNonce,
+          generation: seed.generation,
+          endpointURL: owner.endpointURL,
+          root: owner.root,
+          supervisor: owner.supervisor,
+          proxyURL: owner.proxyURL
+        }).catch(() => disconnect());
+      })();
+      void launching.catch(() => disconnect());
+      return;
+    }
+    const parsed = SupervisorCommandSchema.safeParse(message);
+    if (!parsed.success || parsed.data.nonce !== seed.nonce || parsed.data.sequence !== lastSequence + 1 || pending >= 8) {
+      disconnect();
+      return;
+    }
+    const request = parsed.data;
+    lastSequence = request.sequence;
+    if (request.action.kind === "close") {
+      originalCloseSequence = request.sequence;
+      void close().then(async (returned) => {
+        await send({ kind: "closed", nonce: seed.nonce, sequence: request.sequence, returned });
+        if (process.connected) process.disconnect();
+        process.exitCode = returned ? 0 : 1;
+      }).catch(disconnect);
+      return;
+    }
+    pending++;
+    const operation = tail.then(async () => {
+      await launching;
+      if (stopping || !owner) throw new Error("SUPERVISOR_STOPPED");
+      let value;
+      if (request.action.kind === "list") {
+        for (const page of owner.context.pages()) {
+          if (![...pages.values()].includes(page)) {
+            if (pages.size >= 128) throw new Error("SUPERVISOR_TAB_LIMIT");
+            pages.set(nextTab++, page);
+          }
+        }
+        value = [...pages].filter(([, page]) => !page.isClosed()).map(([tab2, page]) => ({ tab: tab2, url: page.url().slice(0, 4096) }));
+      } else if (request.action.kind === "navigate") {
+        const page = pages.get(request.action.tab), url = new URL(request.action.url);
+        if (!page || page.isClosed() || !["http:", "https:"].includes(url.protocol) || !seed.ownedProxy && url.origin !== seed.origin || url.username || url.password)
+          throw new Error("SUPERVISOR_TARGET_REFUSED");
+        await page.goto(url.href, { timeout: 5e3 });
+        value = { tab: request.action.tab };
+      } else throw new Error("SUPERVISOR_ACTION_REFUSED");
+      if (!stopping)
+        await send({ kind: "reply", nonce: seed.nonce, sequence: request.sequence, value });
+    });
+    tail = operation.catch(async (error) => {
+      process.stderr.write(
+        (error instanceof Error ? error.message.slice(0, 1024) : "SUPERVISOR_ACTION_FAILED") + "\n"
+      );
+      if (!stopping)
+        await send({ kind: "refused", nonce: seed.nonce, sequence: request.sequence });
+    }).then(() => {
+      pending--;
+    });
+    void tail.catch(disconnect);
+  });
+}
+if (process.argv[2] === "--private-darwin-browser-supervisor") void runDarwinSupervisorWorker();
+export {
+  runDarwinSupervisorWorker
+};