cdp-toolkit 2.1.0 → 2.2.0

package/dist/bidi/mux-daemon.js

@@ -0,0 +1,3773 @@
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// src/leases.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+function leaseDir() {
+  return process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
+}
+function leaseTtlMs() {
+  const raw = Number(process.env.CDP_LEASE_TTL_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_LEASE_TTL_MS;
+}
+function markLongLivedProcess(value = true) {
+  longLived = value;
+}
+function requireLease() {
+  if (!longLived)
+    return false;
+  const raw = (process.env.CDP_REQUIRE_LEASE ?? "").trim().toLowerCase();
+  return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
+}
+function defaultLabel() {
+  return `pid-${process.pid}`;
+}
+function safeId(id) {
+  return id.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function leaseFile(backend, targetId) {
+  return join(leaseDir(), `lease-${backend}-${safeId(targetId)}.json`);
+}
+function mintToken(backend, targetId, nonce) {
+  return `${backend}:${targetId}:${nonce}`;
+}
+function tokenParts(token) {
+  if (typeof token !== "string")
+    return;
+  const first = token.indexOf(":");
+  const last = token.lastIndexOf(":");
+  if (first <= 0 || last <= first)
+    return;
+  const backend = token.slice(0, first);
+  if (backend !== "chrome" && backend !== "firefox")
+    return;
+  const targetId = token.slice(first + 1, last);
+  const nonce = token.slice(last + 1);
+  if (!targetId.length || !/^[0-9a-f]{24}$/.test(nonce))
+    return;
+  return { backend, targetId, nonce };
+}
+async function readLease(backend, targetId) {
+  let raw;
+  try {
+    raw = await readFile(leaseFile(backend, targetId), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return;
+    throw err;
+  }
+  try {
+    const rec = JSON.parse(raw);
+    if (typeof rec?.nonce === "string" && typeof rec?.pid === "number")
+      return rec;
+  } catch {}
+  return;
+}
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function staleReason(rec, opts) {
+  if (!isPidAlive(rec.pid))
+    return "dead-pid";
+  if (opts.now - rec.lastUsedAt > rec.ttlMs)
+    return "expired";
+  if (opts.liveIds && !opts.liveIds.includes(rec.targetId))
+    return "target-gone";
+  return false;
+}
+async function claimLease(backend, targetId, opts) {
+  const now = opts.now ?? Date.now();
+  await mkdir(leaseDir(), { recursive: true });
+  for (let attempt = 0;attempt < 3; attempt++) {
+    const record = {
+      backend,
+      targetId,
+      nonce: randomBytes(12).toString("hex"),
+      pid: process.pid,
+      label: opts.label,
+      createdAt: now,
+      lastUsedAt: now,
+      ttlMs: opts.ttlMs ?? leaseTtlMs(),
+      auto: opts.auto === true
+    };
+    try {
+      await writeFile(leaseFile(backend, targetId), JSON.stringify(record), { flag: "wx" });
+      return { token: mintToken(backend, targetId, record.nonce), record };
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    const existing = await readLease(backend, targetId);
+    if (!existing)
+      continue;
+    const stale = staleReason(existing, { now, liveIds: opts.liveIds });
+    if (!stale) {
+      throw new LeaseConflictError(`target '${targetId}' is already leased by '${existing.label}' (pid ${existing.pid}); call release_page with that lease's token, or list_leases to inspect it`, targetId, existing.label);
+    }
+    await unlink(leaseFile(backend, targetId)).catch(() => {
+      return;
+    });
+  }
+  throw new LeaseConflictError(`target '${targetId}' could not be claimed after 3 attempts: another process is claiming and releasing it concurrently`, targetId);
+}
+async function releaseLease(token) {
+  const parts = tokenParts(token);
+  if (!parts)
+    return { released: false };
+  const rec = await readLease(parts.backend, parts.targetId);
+  if (!rec || rec.nonce !== parts.nonce)
+    return { released: false };
+  await unlink(leaseFile(parts.backend, parts.targetId)).catch(() => {
+    return;
+  });
+  return { released: true };
+}
+async function releaseLeaseFor(backend, targetId) {
+  if (!await readLease(backend, targetId))
+    return { released: false };
+  await unlink(leaseFile(backend, targetId)).catch(() => {
+    return;
+  });
+  return { released: true };
+}
+function withLeaseScope(lease, fn) {
+  return leaseScope.run(lease, fn);
+}
+function currentLease() {
+  return leaseScope.getStore();
+}
+function leaseFromArgs(args) {
+  if (!args || typeof args !== "object")
+    return;
+  const lease = args.lease;
+  return typeof lease === "string" && lease.length > 0 ? lease : undefined;
+}
+async function touchLease(rec, now = Date.now()) {
+  const current = await readLease(rec.backend, rec.targetId).catch(() => {
+    return;
+  });
+  if (!current || current.nonce !== rec.nonce)
+    return;
+  await writeFile(leaseFile(current.backend, current.targetId), JSON.stringify({ ...current, lastUsedAt: now }), "utf8").catch(() => {
+    return;
+  });
+}
+function describeTarget(targetId, ctx) {
+  const url = ctx.url ? ` (url ${ctx.url})` : ctx.title ? ` (title ${JSON.stringify(ctx.title)})` : "";
+  return `target '${targetId}'${url}`;
+}
+async function assertLeaseOk(backend, targetId, ctx = {}) {
+  const token = ctx.lease ?? currentLease();
+  const now = ctx.now ?? Date.now();
+  const rec = await readLease(backend, targetId);
+  const held = rec && !staleReason(rec, { now, liveIds: ctx.liveIds }) ? rec : undefined;
+  const where = describeTarget(targetId, ctx);
+  if (token === undefined) {
+    if (!held) {
+      if (requireLease()) {
+        await claimLease(backend, targetId, { label: defaultLabel(), ttlMs: leaseTtlMs(), auto: true, now });
+      }
+      return;
+    }
+    if (held.auto === true && held.pid === process.pid) {
+      await touchLease(held, now);
+      return;
+    }
+    throw new LeaseConflictError(`${where} is leased by '${held.label}' (pid ${held.pid}). Pass that lease's token as the 'lease' argument, or call release_page to free it. list_leases shows every active lease.`, targetId, held.label);
+  }
+  const parts = tokenParts(token);
+  if (!parts) {
+    throw new LeaseConflictError(`malformed lease token for ${where}. Pass back the token claim_page returned, never a constructed one.`, targetId);
+  }
+  if (parts.backend !== backend || parts.targetId !== targetId) {
+    if (!held) {
+      if (requireLease()) {
+        await claimLease(backend, targetId, { label: defaultLabel(), ttlMs: leaseTtlMs(), auto: true, now });
+      }
+      return;
+    }
+    throw new LeaseConflictError(`the lease token you passed is for ${parts.backend} target '${parts.targetId}', not ${where}, which is leased by '${held.label}'. Resolve the tab you actually hold, or claim this one.`, targetId, held.label);
+  }
+  if (!held) {
+    throw new LeaseConflictError(`${where} is not leased any more: the token you passed belongs to a lease that was released or reclaimed. Call claim_page again to take the tab.`, targetId);
+  }
+  if (parts.nonce !== held.nonce) {
+    throw new LeaseConflictError(`${where} was reclaimed and is now leased by '${held.label}' (pid ${held.pid}). Your token was invalidated by that reclamation. Call claim_page again if you still need this tab.`, targetId, held.label);
+  }
+  await touchLease(held, now);
+}
+async function listLeases(opts = {}) {
+  const now = opts.now ?? Date.now();
+  let names = [];
+  try {
+    names = await readdir(leaseDir());
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return [];
+    throw err;
+  }
+  const out = [];
+  for (const name of names) {
+    const parts = LEASE_FILE_RE.exec(name);
+    if (!parts)
+      continue;
+    const fromName = {
+      backend: parts[1],
+      targetId: parts[2],
+      label: "",
+      pid: 0,
+      createdAt: 0,
+      lastUsedAt: 0,
+      ttlMs: 0,
+      pidAlive: false,
+      stale: false
+    };
+    let rec;
+    try {
+      rec = JSON.parse(await readFile(join(leaseDir(), name), "utf8"));
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        continue;
+      out.push({ ...fromName, unreadable: code ?? "unparseable" });
+      continue;
+    }
+    if (typeof rec?.nonce !== "string" || typeof rec?.pid !== "number") {
+      out.push({ ...fromName, unreadable: "unparseable" });
+      continue;
+    }
+    out.push({
+      backend: rec.backend,
+      targetId: rec.targetId,
+      label: rec.label,
+      pid: rec.pid,
+      createdAt: rec.createdAt,
+      lastUsedAt: rec.lastUsedAt,
+      ttlMs: rec.ttlMs,
+      pidAlive: isPidAlive(rec.pid),
+      stale: staleReason(rec, {
+        now,
+        liveIds: opts.liveBackend === undefined || opts.liveBackend === rec.backend ? opts.liveIds : undefined
+      })
+    });
+  }
+  return out;
+}
+var DEFAULT_LEASE_TTL_MS = 900000, longLived = false, LeaseConflictError, leaseScope, LEASE_FILE_RE;
+var init_leases = __esm(() => {
+  LeaseConflictError = class LeaseConflictError extends Error {
+    targetId;
+    holder;
+    constructor(message, targetId, holder) {
+      super(message);
+      this.targetId = targetId;
+      this.holder = holder;
+      this.name = "LeaseConflictError";
+    }
+  };
+  leaseScope = new AsyncLocalStorage;
+  LEASE_FILE_RE = /^lease-(chrome|firefox)-(.+)\.json$/;
+});
+
+// src/bidi/session-lease.ts
+import { mkdir as mkdir2, readFile as readFile2, rename, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+function safeEndpoint(endpoint) {
+  return endpoint.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function sessionSlotFile(endpoint) {
+  return join2(leaseDir(), `ff-session-${safeEndpoint(endpoint)}.json`);
+}
+function muxDaemonLogFile(endpoint) {
+  return join2(leaseDir(), `ff-mux-${safeEndpoint(endpoint)}.log`);
+}
+function sessionWaitMs() {
+  const raw = Number(process.env.CDP_FIREFOX_SESSION_WAIT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_SESSION_WAIT_MS;
+}
+async function readSessionSlot(endpoint) {
+  let raw;
+  try {
+    raw = await readFile2(sessionSlotFile(endpoint), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return;
+    throw err;
+  }
+  try {
+    const rec = JSON.parse(raw);
+    if (typeof rec?.pid === "number" && typeof rec?.endpoint === "string" && typeof rec?.label === "string") {
+      return rec;
+    }
+  } catch {}
+  return;
+}
+async function acquireSessionSlot(endpoint, opts) {
+  const waitMs = opts.waitMs ?? sessionWaitMs();
+  const pollMs = opts.pollMs !== undefined && opts.pollMs > 0 ? opts.pollMs : DEFAULT_POLL_MS;
+  const createdAt = opts.now ?? Date.now();
+  const file = sessionSlotFile(endpoint);
+  const record = {
+    endpoint,
+    pid: process.pid,
+    label: opts.label,
+    createdAt
+  };
+  if (opts.marionettePort !== undefined)
+    record.marionettePort = opts.marionettePort;
+  const handle = { endpoint, pid: process.pid, createdAt };
+  const payload = JSON.stringify(record);
+  await mkdir2(leaseDir(), { recursive: true });
+  const deadline = Date.now() + waitMs;
+  const maxAttempts = Math.max(100, Math.ceil(waitMs / pollMs) + 100);
+  let attempts = 0;
+  let lastLiveHolder;
+  while (true) {
+    if (attempts >= maxAttempts)
+      throw new SessionSlotBusyError(endpoint, lastLiveHolder);
+    attempts++;
+    try {
+      await writeFile2(file, payload, { flag: "wx" });
+      return { handle };
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    const holder = await readSessionSlot(endpoint);
+    if (!holder)
+      continue;
+    if (!isPidAlive(holder.pid)) {
+      await unlink2(file).catch(() => {
+        return;
+      });
+      try {
+        await writeFile2(file, payload, { flag: "wx" });
+        return { handle, staleHolder: holder };
+      } catch (err) {
+        if (err.code !== "EEXIST")
+          throw err;
+        continue;
+      }
+    }
+    if (typeof holder.muxEndpoint === "string" && holder.muxEndpoint.length > 0 && process.env.CDP_FIREFOX_MUX !== "off") {
+      return { joinMux: { endpoint: holder.muxEndpoint, holder } };
+    }
+    lastLiveHolder = holder;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0)
+      throw new SessionSlotBusyError(endpoint, holder);
+    await sleep(Math.min(pollMs, remaining));
+  }
+}
+async function advertiseMux(handle, muxEndpoint) {
+  const current = await readSessionSlot(handle.endpoint);
+  if (!current)
+    return { advertised: false };
+  if (current.pid !== process.pid || current.createdAt !== handle.createdAt)
+    return { advertised: false };
+  const file = sessionSlotFile(handle.endpoint);
+  const tmp = `${file}.tmp-${process.pid}`;
+  const next = { ...current, muxEndpoint };
+  try {
+    await writeFile2(tmp, JSON.stringify(next), "utf8");
+    await rename(tmp, file);
+  } catch {
+    await unlink2(tmp).catch(() => {
+      return;
+    });
+    return { advertised: false };
+  }
+  return { advertised: true };
+}
+async function releaseSessionSlot(handle) {
+  const current = await readSessionSlot(handle.endpoint);
+  if (!current)
+    return { released: false };
+  if (current.pid !== process.pid || current.createdAt !== handle.createdAt)
+    return { released: false };
+  await unlink2(sessionSlotFile(handle.endpoint)).catch(() => {
+    return;
+  });
+  return { released: true };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var DEFAULT_SESSION_WAIT_MS = 1e4, DEFAULT_POLL_MS = 250, SessionSlotBusyError;
+var init_session_lease = __esm(() => {
+  init_leases();
+  SessionSlotBusyError = class SessionSlotBusyError extends Error {
+    endpoint;
+    holderPid;
+    holderLabel;
+    constructor(endpoint, holder) {
+      const who = holder ? `'${holder.label}' (pid ${holder.pid})` : "another live process";
+      super(`Firefox BiDi session slot for endpoint '${endpoint}' is held by ${who}. ` + `Firefox serves exactly ONE WebDriver-BiDi session per browser instance, and this slot is held ` + `by a LIVE process, so it cannot be taken. Wait for that process to release it and retry, or point ` + `this server at a different endpoint/browser.`);
+      this.name = "SessionSlotBusyError";
+      this.endpoint = endpoint;
+      if (holder) {
+        this.holderPid = holder.pid;
+        this.holderLabel = holder.label;
+      }
+    }
+  };
+});
+
+// src/driver.ts
+import { mkdir as mkdir3, readFile as readFile3, unlink as unlink3, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+function isDriverError(e) {
+  return e instanceof Error && typeof e.code === "string";
+}
+function interpolatePoints(from, to, steps) {
+  const out = [];
+  for (let i = 1;i < steps; i++) {
+    out.push({ x: from.x + (to.x - from.x) * i / steps, y: from.y + (to.y - from.y) * i / steps });
+  }
+  out.push({ x: to.x, y: to.y });
+  return out;
+}
+function isTiledCapture(delivery) {
+  return delivery.tiled === true;
+}
+function viewportRecordFile(scheme, targetId) {
+  return join3(leaseDir(), `viewport-${scheme}-${targetId.replace(/[^A-Za-z0-9._-]/g, "_")}.json`);
+}
+async function readViewportRecord(scheme, targetId) {
+  try {
+    const raw = JSON.parse(await readFile3(viewportRecordFile(scheme, targetId), "utf8"));
+    if (typeof raw?.width !== "number" || typeof raw?.height !== "number")
+      return;
+    return {
+      width: raw.width,
+      height: raw.height,
+      ...typeof raw.deviceScaleFactor === "number" ? { deviceScaleFactor: raw.deviceScaleFactor } : {},
+      ...typeof raw.mobile === "boolean" ? { mobile: raw.mobile } : {}
+    };
+  } catch {
+    return;
+  }
+}
+async function writeViewportRecord(scheme, targetId, rec) {
+  try {
+    await mkdir3(leaseDir(), { recursive: true });
+    await writeFile3(viewportRecordFile(scheme, targetId), JSON.stringify({ scheme, targetId, ...rec }), "utf8");
+  } catch {}
+}
+function renderRestoreFailureNote(size, why) {
+  return `— AND the ${size.width}x${size.height} render-size override could NOT be restored (${why}), so this page is STILL ` + `emulated at ${size.width}x${size.height}: put it back with emulate{width,height} or emulate{clearOverrides:true}.`;
+}
+async function clearViewportRecord(scheme, targetId) {
+  try {
+    await unlink3(viewportRecordFile(scheme, targetId));
+  } catch {}
+}
+var UID_STAMP_ATTR = "data-cdp-uid", LEGACY_NUMERIC_UID, REQUIRED_CAPABILITIES;
+var init_driver = __esm(() => {
+  init_leases();
+  LEGACY_NUMERIC_UID = /^[0-9]+$/;
+  REQUIRED_CAPABILITIES = {
+    performance_start_trace: ["trace.performance"],
+    performance_stop_trace: ["trace.performance"],
+    performance_analyze_insight: ["trace.performance"],
+    performance_trace: ["trace.performance"],
+    take_heapsnapshot: ["heap.snapshot"],
+    lighthouse_audit: ["audit.lighthouse"],
+    start_screen_recording: ["capture.screencast"],
+    stop_screen_recording: ["capture.screencast"],
+    mock_request: ["network.intercept"],
+    list_mocks: ["network.intercept"],
+    clear_mocks: ["network.intercept"],
+    dispatch_mouse: ["input.raw"],
+    wait_for_download: ["browser.downloads"],
+    grant_permissions: ["browser.permissions"]
+  };
+});
+
+// src/origins.ts
+import { mkdir as mkdir4, readFile as readFile4, readdir as readdir2, unlink as unlink4, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function safeId2(id) {
+  return id.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function originFile(backend, targetId) {
+  return join4(leaseDir(), `origin-${backend}-${safeId2(targetId)}.json`);
+}
+async function recordOrigin(backend, targetId, opts = {}) {
+  const record = {
+    backend,
+    targetId,
+    label: typeof opts.label === "string" && opts.label.length ? opts.label : defaultLabel(),
+    pid: process.pid,
+    createdAt: opts.now ?? Date.now()
+  };
+  const file = originFile(backend, targetId);
+  try {
+    await mkdir4(leaseDir(), { recursive: true });
+    try {
+      await writeFile4(file, JSON.stringify(record), { flag: "wx" });
+      return;
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    await unlink4(file).catch(() => {
+      return;
+    });
+    await writeFile4(file, JSON.stringify(record), { flag: "wx" });
+  } catch {}
+}
+async function readOrigin(backend, targetId) {
+  let raw;
+  try {
+    raw = await readFile4(originFile(backend, targetId), "utf8");
+  } catch {
+    return;
+  }
+  try {
+    const rec = JSON.parse(raw);
+    if (typeof rec?.targetId === "string" && typeof rec?.label === "string" && typeof rec?.createdAt === "number")
+      return rec;
+  } catch {}
+  return;
+}
+async function listOrigins(opts = {}) {
+  let names = [];
+  try {
+    names = await readdir2(leaseDir());
+  } catch {
+    return [];
+  }
+  const live = opts.liveIds === undefined ? undefined : new Set(opts.liveIds.map((id) => safeId2(id)));
+  const out = [];
+  for (const name of names) {
+    const parts = ORIGIN_FILE_RE.exec(name);
+    if (!parts)
+      continue;
+    const backend = parts[1];
+    const nameId = parts[2];
+    const scoped = live !== undefined && (opts.liveBackend === undefined || opts.liveBackend === backend);
+    if (scoped && !live.has(nameId)) {
+      await unlink4(join4(leaseDir(), name)).catch(() => {
+        return;
+      });
+      continue;
+    }
+    const fromName = { backend, targetId: nameId, label: "", pid: 0, createdAt: 0 };
+    let rec;
+    try {
+      rec = JSON.parse(await readFile4(join4(leaseDir(), name), "utf8"));
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        continue;
+      out.push({ ...fromName, unreadable: code ?? "unparseable" });
+      continue;
+    }
+    if (typeof rec?.targetId !== "string" || typeof rec?.label !== "string" || typeof rec?.createdAt !== "number") {
+      out.push({ ...fromName, unreadable: "unparseable" });
+      continue;
+    }
+    out.push({ backend: rec.backend, targetId: rec.targetId, label: rec.label, pid: rec.pid, createdAt: rec.createdAt });
+  }
+  return out;
+}
+async function originIndex(backend, liveIds) {
+  const rows = await listOrigins({ liveIds, liveBackend: backend }).catch(() => []);
+  const index = new Map;
+  for (const row of rows) {
+    if (row.backend !== backend)
+      continue;
+    index.set(row.targetId, row);
+  }
+  return index;
+}
+async function newTrackedPage(driver, backend, opts = {}) {
+  const page = await driver.newPage(opts.url);
+  await recordOrigin(backend, page.id, { label: opts.label });
+  return page;
+}
+async function resolveLiveLabel(backend, label, liveIds) {
+  const live = new Set(liveIds);
+  const [origins, leases] = await Promise.all([originIndex(backend), listLeases({ liveBackend: backend })]);
+  const knownLabels = new Set;
+  const matchIds = new Set;
+  for (const rec of origins.values()) {
+    if (rec.unreadable !== undefined || !live.has(rec.targetId))
+      continue;
+    knownLabels.add(rec.label);
+    if (rec.label === label)
+      matchIds.add(rec.targetId);
+  }
+  for (const rec of leases) {
+    if (rec.backend !== backend || rec.unreadable !== undefined || !live.has(rec.targetId))
+      continue;
+    knownLabels.add(rec.label);
+    if (rec.label === label)
+      matchIds.add(rec.targetId);
+  }
+  return { matchIds: [...matchIds], knownLabels: [...knownLabels].sort() };
+}
+var ORIGIN_FILE_RE;
+var init_origins = __esm(() => {
+  init_leases();
+  ORIGIN_FILE_RE = /^origin-(chrome|firefox)-(.+)\.json$/;
+});
+
+// src/workers.ts
+function isWorkerSelector(selector) {
+  return typeof selector === "string" && selector.startsWith(WORKER_SELECTOR_PREFIX);
+}
+function workerNeedle(selector) {
+  return selector.slice(WORKER_SELECTOR_PREFIX.length);
+}
+function isWorkerTargetType(type) {
+  return type !== undefined && WORKER_TARGET_TYPES.has(type);
+}
+function resolveWorkerTargets(targets, needle) {
+  const liveWorkers = targets.filter((t) => isWorkerTargetType(t.type));
+  return {
+    matches: needle === "" ? [] : liveWorkers.filter((t) => t.url.includes(needle)),
+    liveWorkers
+  };
+}
+function workerWakeMisuseMessage(kind) {
+  if (kind === "not-a-worker-selector") {
+    return "'wake' only applies to a target of the form 'worker:<substring>'. A page is never asleep, and a bare " + "worker target id cannot be woken either: Chrome destroys the target when an MV3 worker is evicted and " + "mints a NEW id when it restarts, so only the url-substring form can name a worker that is not running.";
+  }
+  return "'wake' only applies when a capture is being started (reload:true, or includeBody with url). Reading an " + "existing buffer cannot use a woken worker: a restarted MV3 worker gets a NEW target id, and the buffer is " + "keyed by id, so the wake would hand back an empty capture. Re-run with reload:true to record a fresh one.";
+}
+function workerBufferReadMissMessage(needle, liveWorkers) {
+  const running = liveWorkers.length ? ` (running workers: ${urlList(liveWorkers)})` : " (no workers are running)";
+  return `no running worker whose url contains '${needle}'${running}. ` + "An MV3 extension service worker is idle-evicted after seconds of inactivity and then appears in NO target " + "listing, so this is usually a sleeping worker rather than a wrong substring. This call only READS a buffer " + "recorded earlier, and that buffer is keyed by the worker's target id, which Chrome re-mints on restart — so " + "re-run with reload:true, which starts the worker and records a fresh capture window.";
+}
+function urlList(workers) {
+  return workers.map((w) => w.url).join(", ");
+}
+function workerAmbiguityMessage(needle, matches) {
+  return `'worker:${needle}' matches more than one running worker: ` + matches.map((m) => `${m.url} (${m.id})`).join(", ") + ". Narrow the substring, or pass the worker's target id directly.";
+}
+function workerMissMessage(needle, opts) {
+  const running = opts.liveWorkers?.length ? ` (running workers: ${urlList(opts.liveWorkers)})` : " (no workers are running)";
+  if (!opts.wakeAttempted) {
+    return `no running worker whose url contains '${needle}'${running}. ` + "An MV3 extension service worker is idle-evicted after seconds of inactivity and then appears in NO target " + "listing, so this is usually a sleeping worker rather than a wrong substring. You passed wake:false; " + "wake:true (the default) asks Chrome to start it first.";
+  }
+  const scopes = opts.registeredScopes?.length ? ` Registered service-worker scopes in this browser: ${opts.registeredScopes.join(", ")}.` : " No service-worker registrations were reported by this browser at all.";
+  return `no worker whose url contains '${needle}' could be reached${running}. ` + `A start was requested (wake:true) and no matching worker appeared.${scopes} ` + "If the extension is installed but its worker never starts, check the worker script for a top-level throw.";
+}
+var WORKER_SELECTOR_PREFIX = "worker:", WORKER_CAPABLE_TOOLS, WORKER_TARGET_TYPES, WORKER_EMPTY_NEEDLE_MESSAGE = "'worker:' needs a substring of the worker's url, e.g. worker:<extension-id> or worker:background.js", WORKER_SELECTOR_UNSUPPORTED_MESSAGE, WORKER_SELECTOR_PAGE_ONLY_MESSAGE;
+var init_workers = __esm(() => {
+  WORKER_CAPABLE_TOOLS = [
+    "evaluate_script",
+    "list_network_requests",
+    "get_network_request",
+    "list_console_messages"
+  ];
+  WORKER_TARGET_TYPES = new Set(["service_worker", "shared_worker"]);
+  WORKER_SELECTOR_UNSUPPORTED_MESSAGE = "target 'worker:<substring>' selects a service/shared worker, which this backend cannot address " + "(WebDriver BiDi has no extension service-worker target; Capability 'worker.targets' is Chrome-only). " + "Use --browser chrome to evaluate in, or record console/network from, an extension's background worker.";
+  WORKER_SELECTOR_PAGE_ONLY_MESSAGE = "target 'worker:<substring>' selects a service/shared worker, and this tool is page-only " + "(closing, selecting or releasing a worker is meaningless). The tools that accept a worker: target are " + `${WORKER_CAPABLE_TOOLS.join(", ")}.`;
+});
+
+// src/activity.ts
+function dispatchKey(backend, targetId) {
+  return `${backend}:${targetId}`;
+}
+function recordDispatch(backend, targetId, now = Date.now()) {
+  const key = dispatchKey(backend, targetId);
+  dispatchLog.delete(key);
+  dispatchLog.set(key, now);
+  while (dispatchLog.size > DISPATCH_LOG_LIMIT) {
+    const oldest = dispatchLog.keys().next();
+    if (oldest.done)
+      break;
+    dispatchLog.delete(oldest.value);
+  }
+}
+async function sendInput(conn, backend, targetId, method, params = {}) {
+  if (!NON_SYNTHESIZING_INPUT_METHODS.has(method))
+    recordDispatch(backend, targetId);
+  return conn.send(method, params);
+}
+function lastDispatchAt(backend, targetId) {
+  return dispatchLog.get(dispatchKey(backend, targetId));
+}
+function isHumanAttributed(beaconTs, dispatchAt, windowMs = DISPATCH_ATTRIBUTION_WINDOW_MS) {
+  if (typeof beaconTs !== "number" || !Number.isFinite(beaconTs))
+    return false;
+  return beaconTs > (dispatchAt ?? 0) + windowMs;
+}
+function humanActiveMs(beaconTs, dispatchAt, now = Date.now(), windowMs = DISPATCH_ATTRIBUTION_WINDOW_MS) {
+  if (!isHumanAttributed(beaconTs, dispatchAt, windowMs))
+    return null;
+  return Math.max(0, now - beaconTs);
+}
+function contentionWarning(ms, opts) {
+  if (!opts.takeover)
+    return;
+  if (ms === null || ms >= CONTENTION_WINDOW_MS)
+    return;
+  return `a person appears to be using this tab right now: input not dispatched by this server landed ${ms}ms ago. ` + `The claim SUCCEEDED and you hold the lease — this is a warning, not a refusal. ` + `Driving the tab now will fight them for the keyboard and mouse. ` + `Consider claim_page with no target to work in your own tab instead, or ask before continuing.`;
+}
+function beaconSupported(driver) {
+  return typeof driver.installActivityBeacon === "function" && typeof driver.readActivityBeacon === "function";
+}
+async function installBeacon(driver, targetId) {
+  if (typeof driver.installActivityBeacon !== "function")
+    return false;
+  return driver.installActivityBeacon(targetId).catch(() => false);
+}
+async function readHumanActiveMs(driver, backend, targetId, now = Date.now()) {
+  if (typeof driver.readActivityBeacon !== "function")
+    return null;
+  const beaconTs = await driver.readActivityBeacon(targetId).catch(() => null);
+  return humanActiveMs(beaconTs, lastDispatchAt(backend, targetId), now);
+}
+function rendererProbeSupported(driver) {
+  return typeof driver.probeRenderer === "function";
+}
+async function probeRendererActivity(driver, backend, targetId, now = Date.now()) {
+  if (typeof driver.probeRenderer !== "function")
+    return { responsive: false };
+  const { responsive, beaconTs } = await driver.probeRenderer(targetId, RENDERER_PROBE_TIMEOUT_MS).catch(() => ({ responsive: false, beaconTs: null }));
+  const ms = humanActiveMs(beaconTs, lastDispatchAt(backend, targetId), now);
+  return ms === null ? { responsive } : { responsive, humanActiveMs: ms };
+}
+
+class BeaconSessions {
+  close;
+  limit;
+  live = new Map;
+  constructor(close, limit = 32) {
+    this.close = close;
+    this.limit = limit;
+  }
+  get(key) {
+    return this.live.get(key);
+  }
+  set(key, value) {
+    const previous = this.live.get(key);
+    if (previous !== undefined) {
+      this.live.delete(key);
+      this.safeClose(previous);
+    }
+    this.live.set(key, value);
+    while (this.live.size > this.limit) {
+      const oldest = this.live.keys().next();
+      if (oldest.done)
+        break;
+      this.drop(oldest.value);
+    }
+  }
+  drop(key) {
+    const value = this.live.get(key);
+    if (value === undefined)
+      return;
+    this.live.delete(key);
+    this.safeClose(value);
+  }
+  clear() {
+    for (const key of [...this.live.keys()])
+      this.drop(key);
+  }
+  get size() {
+    return this.live.size;
+  }
+  safeClose(value) {
+    try {
+      this.close(value);
+    } catch {}
+  }
+}
+var BEACON_DATA_GLOBAL = "__cdpToolkitLastInput", BEACON_INSTALLED_GLOBAL = "__cdpToolkitBeacon", BEACON_EVENTS, BEACON_BODY, BEACON_SOURCE, BEACON_FUNCTION_DECLARATION, BEACON_READ_EXPRESSION, DISPATCH_ATTRIBUTION_WINDOW_MS = 1500, dispatchLog, DISPATCH_LOG_LIMIT = 512, NON_SYNTHESIZING_INPUT_METHODS, CONTENTION_WINDOW_MS = 30000, RENDERER_PROBE_TIMEOUT_MS = 500, RENDERER_PROBE_EXPRESSION;
+var init_activity = __esm(() => {
+  BEACON_EVENTS = ["pointerdown", "mousedown", "keydown", "wheel", "touchstart"];
+  BEACON_BODY = `
+  if (!window.${BEACON_INSTALLED_GLOBAL}) {
+    window.${BEACON_INSTALLED_GLOBAL} = true;
+    var mark = function () { window.${BEACON_DATA_GLOBAL} = Date.now(); };
+    var events = ${JSON.stringify([...BEACON_EVENTS])};
+    for (var i = 0; i < events.length; i++) {
+      window.addEventListener(events[i], mark, { capture: true, passive: true });
+    }
+  }`;
+  BEACON_SOURCE = `(function () {${BEACON_BODY}
+})();`;
+  BEACON_FUNCTION_DECLARATION = `function () {${BEACON_BODY}
+}`;
+  BEACON_READ_EXPRESSION = `(typeof window.${BEACON_DATA_GLOBAL} === "number" ? window.${BEACON_DATA_GLOBAL} : null)`;
+  dispatchLog = new Map;
+  NON_SYNTHESIZING_INPUT_METHODS = new Set(["Input.setInterceptDrags", "Input.setIgnoreInputEvents"]);
+  RENDERER_PROBE_EXPRESSION = `[1, ${BEACON_READ_EXPRESSION}]`;
+});
+
+// src/bidi/client.ts
+class BidiConnection {
+  wsUrl;
+  opts;
+  ws;
+  nextId = 0;
+  sessId;
+  caps;
+  closed = false;
+  refCount = 0;
+  pending = new Map;
+  listeners = new Map;
+  constructor(wsUrl, opts = {}) {
+    this.wsUrl = wsUrl;
+    this.opts = opts;
+  }
+  get sessionId() {
+    return this.sessId;
+  }
+  get capabilities() {
+    return this.caps;
+  }
+  get holders() {
+    return this.refCount;
+  }
+  get isOpen() {
+    return !this.closed && this.ws !== undefined;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.wsUrl);
+      this.ws = ws;
+      const openTimer = setTimeout(() => reject(new BidiError(`connect timeout: ${this.wsUrl}`)), this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+      ws.onopen = () => {
+        clearTimeout(openTimer);
+        resolve(this);
+      };
+      ws.onerror = (e) => {
+        clearTimeout(openTimer);
+        const msg = e?.message ?? "websocket error";
+        if (this.pending.size === 0)
+          reject(new BidiError(msg));
+        this.rejectAll(new BidiError(msg));
+      };
+      ws.onclose = () => {
+        this.closed = true;
+        this.rejectAll(new BidiError("connection closed"));
+      };
+      ws.onmessage = (ev) => this.onMessage(String(ev.data));
+    });
+  }
+  async newSession(capabilities = {}) {
+    const result = await this.send("session.new", { capabilities });
+    this.sessId = result.sessionId;
+    this.caps = result.capabilities;
+    return result.sessionId;
+  }
+  onMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.type === "success" || msg.type === "error") {
+      const id = msg.id;
+      if (typeof id !== "number" || !this.pending.has(id))
+        return;
+      const p = this.pending.get(id);
+      clearTimeout(p.timer);
+      this.pending.delete(id);
+      p.resolve(msg);
+      return;
+    }
+    if (msg.type === "event") {
+      const set = this.listeners.get(msg.method);
+      if (set)
+        for (const h of set)
+          h(msg.params);
+    }
+  }
+  rejectAll(err) {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+  send(method, params, opts = {}) {
+    if (this.closed || !this.ws)
+      return Promise.reject(new BidiError("connection not open"));
+    const id = ++this.nextId;
+    const timeoutMs = opts.timeoutMs ?? this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const payload = { id, method, params };
+    return new Promise((resolve, reject) => {
+      const start = Date.now();
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        const elapsed = Date.now() - start;
+        reject(new BidiError(`'${method}' timed out after ${elapsed}ms`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        method,
+        start,
+        timer,
+        resolve: (raw) => {
+          if (raw.type === "error")
+            reject(new BidiError(`${method}: ${raw.message}`, raw.error));
+          else
+            resolve(raw.result);
+        },
+        reject
+      });
+      this.ws.send(JSON.stringify(payload));
+    });
+  }
+  on(event, handler) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(event, set);
+    }
+    const first = set.size === 0;
+    set.add(handler);
+    if (first) {
+      this.send("session.subscribe", { events: [event] }).catch(() => {});
+    }
+    let removed = false;
+    return () => {
+      if (removed)
+        return;
+      removed = true;
+      const s = this.listeners.get(event);
+      s?.delete(handler);
+      if (s && s.size === 0) {
+        this.send("session.unsubscribe", { events: [event] }).catch(() => {});
+      }
+    };
+  }
+  waitFor(event, predicate, timeoutMs = this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        off();
+        reject(new BidiError(`waitFor('${event}') timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const off = this.on(event, (params) => {
+        if (!predicate || predicate(params)) {
+          clearTimeout(timer);
+          off();
+          resolve(params);
+        }
+      });
+    });
+  }
+  retain() {
+    this.refCount++;
+  }
+  release() {
+    if (this.refCount > 0)
+      this.refCount--;
+  }
+  dispose() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.rejectAll(new BidiError("connection disposed"));
+    try {
+      this.ws?.close();
+    } catch {}
+  }
+}
+async function connectBidiSessionUrl(wsUrl, opts = {}) {
+  const conn = new BidiConnection(wsUrl, { timeoutMs: opts.timeoutMs });
+  await conn.connect();
+  try {
+    await conn.newSession(opts.capabilities ?? {});
+  } catch (e) {
+    conn.dispose();
+    throw e;
+  }
+  conn.retain();
+  return conn;
+}
+var DEFAULT_TIMEOUT_MS, BidiError;
+var init_client = __esm(() => {
+  DEFAULT_TIMEOUT_MS = Number(process.env.BIDI_TIMEOUT_MS ?? 15000);
+  BidiError = class BidiError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+      super(message);
+      this.code = code;
+      this.data = data;
+      this.name = "BidiError";
+    }
+  };
+});
+
+// src/bidi/mux.ts
+import { createServer } from "node:net";
+import { createHash } from "node:crypto";
+function acceptKey(key) {
+  return createHash("sha1").update(key + WS_GUID).digest("base64");
+}
+function encodeFrame(opcode, payload) {
+  const len = payload.length;
+  let header;
+  if (len < 126) {
+    header = Buffer.alloc(2);
+    header[1] = len;
+  } else if (len < 65536) {
+    header = Buffer.alloc(4);
+    header[1] = 126;
+    header.writeUInt16BE(len, 2);
+  } else {
+    header = Buffer.alloc(10);
+    header[1] = 127;
+    header.writeBigUInt64BE(BigInt(len), 2);
+  }
+  header[0] = 128 | opcode;
+  return Buffer.concat([header, payload]);
+}
+function encodeClose(code, reason) {
+  const r = Buffer.from(reason, "utf8");
+  const body = Buffer.alloc(2 + r.length);
+  body.writeUInt16BE(code, 0);
+  r.copy(body, 2);
+  return encodeFrame(8, body);
+}
+function createWsServer(opts) {
+  const host = opts.host ?? "127.0.0.1";
+  const path = opts.path ?? "/session";
+  const clients = new Set;
+  const sockets = new Set;
+  const server = createServer((socket) => {
+    sockets.add(socket);
+    socket.setNoDelay(true);
+    let buf = Buffer.alloc(0);
+    let upgraded = false;
+    let fragments = [];
+    let fragmentOpcode = -1;
+    let dead = false;
+    let client;
+    const drop = () => {
+      if (dead)
+        return;
+      dead = true;
+      sockets.delete(socket);
+      if (client) {
+        clients.delete(client);
+        try {
+          client.onClose?.();
+        } catch {}
+      }
+    };
+    const dispatch = (payload) => {
+      try {
+        client?.onMessage?.(payload.toString("utf8"));
+      } catch {}
+    };
+    function handshake() {
+      const end = buf.indexOf(`\r
+\r
+`);
+      if (end === -1) {
+        if (buf.length > 16 * 1024) {
+          socket.end(`HTTP/1.1 431 Request Header Fields Too Large\r
+Connection: close\r
+\r
+`);
+          drop();
+          return false;
+        }
+        return false;
+      }
+      const header = buf.subarray(0, end).toString("latin1");
+      buf = buf.subarray(end + 4);
+      const lines = header.split(`\r
+`);
+      const reqPath = (lines[0] ?? "").split(" ")[1]?.split("?")[0] ?? "";
+      const headers = new Map;
+      for (const line of lines.slice(1)) {
+        const i = line.indexOf(":");
+        if (i > 0)
+          headers.set(line.slice(0, i).trim().toLowerCase(), line.slice(i + 1).trim());
+      }
+      if (reqPath !== path) {
+        socket.end(`HTTP/1.1 404 Not Found\r
+Connection: close\r
+\r
+`);
+        drop();
+        return false;
+      }
+      const key = headers.get("sec-websocket-key");
+      if (!key || (headers.get("upgrade") ?? "").toLowerCase() !== "websocket") {
+        socket.end(`HTTP/1.1 400 Bad Request\r
+Connection: close\r
+\r
+`);
+        drop();
+        return false;
+      }
+      socket.write(`HTTP/1.1 101 Switching Protocols\r
+` + `Upgrade: websocket\r
+` + `Connection: Upgrade\r
+` + `Sec-WebSocket-Accept: ${acceptKey(key)}\r
+\r
+`);
+      upgraded = true;
+      const c = {
+        send(text) {
+          if (dead || socket.destroyed)
+            return;
+          try {
+            socket.write(encodeFrame(1, Buffer.from(text, "utf8")));
+          } catch {}
+        },
+        close(code, reason = "") {
+          if (dead || socket.destroyed) {
+            drop();
+            return;
+          }
+          try {
+            socket.write(encodeClose(code, reason));
+          } catch {}
+          drop();
+          try {
+            socket.end();
+          } catch {}
+        }
+      };
+      client = c;
+      clients.add(c);
+      opts.onConnection(c);
+      return true;
+    }
+    socket.on("data", (chunk) => {
+      try {
+        buf = buf.length === 0 ? chunk : Buffer.concat([buf, chunk]);
+        if (!upgraded && !handshake())
+          return;
+        const c = client;
+        if (!c)
+          return;
+        for (;; ) {
+          if (dead)
+            return;
+          if (buf.length < 2)
+            return;
+          const b0 = buf[0];
+          const b1 = buf[1];
+          const fin = (b0 & 128) !== 0;
+          const opcode = b0 & 15;
+          const masked = (b1 & 128) !== 0;
+          let len = b1 & 127;
+          let off = 2;
+          if (len === 126) {
+            if (buf.length < off + 2)
+              return;
+            len = buf.readUInt16BE(off);
+            off += 2;
+          } else if (len === 127) {
+            if (buf.length < off + 8)
+              return;
+            const big = buf.readBigUInt64BE(off);
+            if (big > BigInt(MAX_MESSAGE_BYTES)) {
+              c.close(1009, "message too big");
+              return;
+            }
+            len = Number(big);
+            off += 8;
+          }
+          if (len > MAX_MESSAGE_BYTES) {
+            c.close(1009, "message too big");
+            return;
+          }
+          let maskKey;
+          if (masked) {
+            if (buf.length < off + 4)
+              return;
+            maskKey = buf.subarray(off, off + 4);
+            off += 4;
+          }
+          if (buf.length < off + len)
+            return;
+          const payload = Buffer.from(buf.subarray(off, off + len));
+          buf = buf.subarray(off + len);
+          if (maskKey) {
+            for (let i = 0;i < payload.length; i++)
+              payload[i] = payload[i] ^ maskKey[i % 4];
+          }
+          if (opcode === 8) {
+            const code = payload.length >= 2 ? payload.readUInt16BE(0) : 1000;
+            c.close(code === 1005 ? 1000 : code, "");
+            return;
+          }
+          if (opcode === 9) {
+            if (!socket.destroyed)
+              socket.write(encodeFrame(10, payload));
+            continue;
+          }
+          if (opcode === 10)
+            continue;
+          if (opcode === 2) {
+            c.close(1003, "binary frames unsupported");
+            return;
+          }
+          if (opcode === 1 || opcode === 0) {
+            if (opcode === 1) {
+              if (fragmentOpcode !== -1) {
+                c.close(1002, "interleaved fragments");
+                return;
+              }
+              if (fin) {
+                dispatch(payload);
+                continue;
+              }
+              fragmentOpcode = 1;
+              fragments = [payload];
+              continue;
+            }
+            if (fragmentOpcode === -1) {
+              c.close(1002, "continuation without start");
+              return;
+            }
+            fragments.push(payload);
+            const total = fragments.reduce((n, f) => n + f.length, 0);
+            if (total > MAX_MESSAGE_BYTES) {
+              c.close(1009, "message too big");
+              return;
+            }
+            if (fin) {
+              const whole = Buffer.concat(fragments);
+              fragments = [];
+              fragmentOpcode = -1;
+              dispatch(whole);
+            }
+            continue;
+          }
+          c.close(1002, "unsupported opcode");
+          return;
+        }
+      } catch {
+        try {
+          client?.close(1002, "protocol error");
+        } catch {}
+        drop();
+      }
+    });
+    socket.on("error", () => drop());
+    socket.on("close", () => drop());
+  });
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port ?? 0, host, () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      let closing;
+      resolve({
+        port,
+        clients,
+        close() {
+          if (closing)
+            return closing;
+          closing = new Promise((res) => {
+            let done = false;
+            const finish = () => {
+              if (done)
+                return;
+              done = true;
+              clearInterval(poll);
+              res();
+            };
+            const poll = setInterval(() => {
+              if (!server.listening)
+                finish();
+            }, 20);
+            poll.unref?.();
+            server.close(finish);
+            server.once("close", finish);
+            for (const s of sockets) {
+              try {
+                s.destroy();
+              } catch {}
+            }
+            sockets.clear();
+          });
+          return closing;
+        }
+      });
+    });
+  });
+}
+async function startBidiMux(upstream, opts = {}) {
+  const host = opts.host ?? "127.0.0.1";
+  const states = new Map;
+  const subs = new Map;
+  let sessionSeq = 0;
+  let closed = false;
+  let closing;
+  const server = await createWsServer({
+    host,
+    port: opts.port ?? 0,
+    path: "/session",
+    onConnection: (client) => {
+      states.set(client, { sessionId: `mux-${++sessionSeq}`, subscribed: new Set });
+      client.onMessage = (raw) => void handleMessage(client, raw);
+      client.onClose = () => releaseClient(client);
+    }
+  });
+  const endpoint = `ws://${host}:${server.port}/session`;
+  function send(client, obj) {
+    client.send(JSON.stringify(obj));
+  }
+  function fanOut(event, params) {
+    for (const [client, state] of states) {
+      if (state.subscribed.has(event))
+        send(client, { type: "event", method: event, params });
+    }
+  }
+  function subscribeOne(client, event) {
+    const state = states.get(client);
+    if (!state || state.subscribed.has(event))
+      return;
+    state.subscribed.add(event);
+    const existing = subs.get(event);
+    if (existing) {
+      existing.count++;
+      return;
+    }
+    const off = upstream.on(event, (params) => fanOut(event, params));
+    subs.set(event, { count: 1, off });
+  }
+  function unsubscribeOne(client, event) {
+    const state = states.get(client);
+    if (!state || !state.subscribed.has(event))
+      return;
+    state.subscribed.delete(event);
+    const entry = subs.get(event);
+    if (!entry)
+      return;
+    entry.count--;
+    if (entry.count <= 0) {
+      subs.delete(event);
+      try {
+        entry.off();
+      } catch {}
+    }
+  }
+  function releaseClient(client) {
+    const state = states.get(client);
+    if (!state)
+      return;
+    for (const event of [...state.subscribed])
+      unsubscribeOne(client, event);
+    states.delete(client);
+  }
+  function eventsOf(params) {
+    const raw = params?.events;
+    return Array.isArray(raw) ? raw.filter((e) => typeof e === "string") : [];
+  }
+  async function handleMessage(client, raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      client.close(1002, "invalid JSON");
+      return;
+    }
+    const id = msg.id;
+    const method = msg.method;
+    if (typeof id !== "number" || typeof method !== "string") {
+      return;
+    }
+    const params = msg.params;
+    const state = states.get(client);
+    if (method === "session.new") {
+      send(client, {
+        type: "success",
+        id,
+        result: { sessionId: state?.sessionId ?? `mux-${++sessionSeq}`, capabilities: upstream.capabilities }
+      });
+      return;
+    }
+    if (method === "session.end") {
+      releaseClient(client);
+      if (state)
+        states.set(client, { sessionId: state.sessionId, subscribed: new Set });
+      send(client, { type: "success", id, result: {} });
+      return;
+    }
+    if (method === "session.subscribe" || method === "session.unsubscribe") {
+      for (const event of eventsOf(params)) {
+        if (method === "session.subscribe")
+          subscribeOne(client, event);
+        else
+          unsubscribeOne(client, event);
+      }
+      send(client, { type: "success", id, result: {} });
+      return;
+    }
+    if (method === "session.status") {
+      send(client, { type: "success", id, result: { ready: false, message: "multiplexed" } });
+      return;
+    }
+    try {
+      const result = await upstream.send(method, params, {
+        timeoutMs: FORWARD_TIMEOUT_MS
+      });
+      send(client, { type: "success", id, result });
+    } catch (e) {
+      const err = e;
+      const message = err?.message ?? String(e);
+      send(client, {
+        type: "error",
+        id,
+        error: (err instanceof BidiError ? err.code : undefined) ?? "unknown error",
+        message
+      });
+      if (/connection closed|connection disposed|connection not open/.test(message)) {
+        closeAll();
+      }
+    }
+  }
+  const watchdog = setInterval(() => {
+    if (!upstream.isOpen)
+      closeAll();
+  }, 250);
+  watchdog.unref?.();
+  function closeAll() {
+    if (closing)
+      return closing;
+    closed = true;
+    clearInterval(watchdog);
+    closing = (async () => {
+      for (const [client] of [...states]) {
+        try {
+          client.close(1001, "holder closing");
+        } catch {}
+      }
+      states.clear();
+      for (const [, entry] of subs) {
+        try {
+          entry.off();
+        } catch {}
+      }
+      subs.clear();
+      await server.close();
+    })();
+    return closing;
+  }
+  return {
+    endpoint,
+    clients() {
+      return closed ? 0 : server.clients.size;
+    },
+    close() {
+      return closeAll();
+    }
+  };
+}
+var WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", MAX_MESSAGE_BYTES, FORWARD_TIMEOUT_MS = 120000;
+var init_mux = __esm(() => {
+  init_client();
+  MAX_MESSAGE_BYTES = 64 * 1024 * 1024;
+});
+
+// src/bidi/marionette.ts
+import { Socket } from "node:net";
+function defaultMarionettePort() {
+  const raw = Number(process.env.CDP_FIREFOX_MARIONETTE_PORT);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_MARIONETTE_PORT;
+}
+function encodeFrame2(json) {
+  const body = Buffer.from(JSON.stringify(json), "utf8");
+  const prefix = Buffer.from(`${body.length}:`, "ascii");
+  return Buffer.concat([prefix, body]);
+}
+
+class FrameDecoder {
+  buf = Buffer.alloc(0);
+  push(chunk) {
+    this.buf = this.buf.length === 0 ? chunk : Buffer.concat([this.buf, chunk]);
+  }
+  next() {
+    const colon = this.buf.indexOf(COLON);
+    if (colon === -1) {
+      this.assertDigitsPrefix(this.buf.length);
+      return;
+    }
+    if (colon === 0)
+      throw new MarionetteProtocolError("empty frame length prefix");
+    this.assertDigitsPrefix(colon);
+    const len = Number.parseInt(this.buf.toString("ascii", 0, colon), 10);
+    const start = colon + 1;
+    const end = start + len;
+    if (this.buf.length < end)
+      return;
+    const payload = this.buf.toString("utf8", start, end);
+    this.buf = this.buf.subarray(end);
+    try {
+      return JSON.parse(payload);
+    } catch {
+      throw new MarionetteProtocolError(`frame body was not valid JSON (${len} bytes): ${payload.slice(0, 80)}`);
+    }
+  }
+  assertDigitsPrefix(upTo) {
+    for (let i = 0;i < upTo; i++) {
+      const b = this.buf[i];
+      if (b < 48 || b > 57) {
+        throw new MarionetteProtocolError(`non-digit byte 0x${b.toString(16)} in frame length prefix`);
+      }
+    }
+  }
+}
+function isSlotFreedReply(frame) {
+  if (!Array.isArray(frame))
+    return false;
+  const err = frame[2];
+  if (err === null)
+    return true;
+  if (typeof err === "object" && err !== null && err.error === "invalid session id") {
+    return true;
+  }
+  return false;
+}
+function forceClearOrphanSession(marionettePort, opts = {}) {
+  const timeoutMs = opts.timeoutMs !== undefined && Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0 ? opts.timeoutMs : DEFAULT_TIMEOUT_MS2;
+  return new Promise((resolve) => {
+    if (!Number.isFinite(marionettePort) || marionettePort <= 0 || marionettePort > 65535) {
+      resolve(false);
+      return;
+    }
+    const sock = new Socket;
+    const decoder = new FrameDecoder;
+    let settled = false;
+    let handshakeSeen = false;
+    let commandSent = false;
+    const settle = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      sock.removeAllListeners();
+      sock.destroy();
+      resolve(value);
+    };
+    const timer = setTimeout(() => settle(false), timeoutMs);
+    if (typeof timer.unref === "function")
+      timer.unref();
+    sock.on("error", () => settle(false));
+    sock.on("close", () => settle(false));
+    sock.on("data", (chunk) => {
+      if (settled)
+        return;
+      try {
+        decoder.push(chunk);
+        for (;; ) {
+          const frame = decoder.next();
+          if (frame === undefined)
+            break;
+          if (!handshakeSeen) {
+            handshakeSeen = true;
+            continue;
+          }
+          settle(isSlotFreedReply(frame));
+          return;
+        }
+        if (handshakeSeen && !commandSent) {
+          commandSent = true;
+          sock.write(DELETE_SESSION_FRAME);
+        }
+      } catch {
+        settle(false);
+      }
+    });
+    try {
+      sock.connect(marionettePort, HOST);
+    } catch {
+      settle(false);
+    }
+  });
+}
+var DEFAULT_MARIONETTE_PORT = 2828, DEFAULT_TIMEOUT_MS2 = 4000, HOST = "127.0.0.1", COLON = 58, DELETE_SESSION_FRAME, MarionetteProtocolError;
+var init_marionette = __esm(() => {
+  DELETE_SESSION_FRAME = encodeFrame2([0, 1, "WebDriver:DeleteSession", {}]);
+  MarionetteProtocolError = class MarionetteProtocolError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "MarionetteProtocolError";
+    }
+  };
+});
+
+// src/bidi/snapshot.ts
+async function takeStampedSnapshot(evaluate) {
+  const raw = await evaluate(buildSnapshotFunctionSource());
+  return coerceSnapshotResult(raw);
+}
+function coerceSnapshotResult(raw) {
+  if (typeof raw !== "object" || raw === null || typeof raw.snapshot !== "string" || typeof raw.nodeCount !== "number") {
+    throw new Error("takeStampedSnapshot: evaluate() returned an unexpected shape");
+  }
+  return { snapshot: raw.snapshot, nodeCount: raw.nodeCount };
+}
+function buildSnapshotFunctionSource() {
+  return `function() {
+    var STAMP_ATTR = ${JSON.stringify(STAMP_ATTR)};
+    var MAX_NAME_LENGTH = ${MAX_NAME_LENGTH};
+    var lines = [];
+    var nodeCount = 0;
+
+    // THE UID CODEC (driver.ts) documents a bidi payload as exactly 12 lowercase hex chars,
+    // /^[0-9a-f]{12}$/. Build it from two padded random blocks so the length is exact regardless
+    // of the random value drawn, never from string concatenation that could come up short.
+    function nextStamp() {
+      var hi = Math.floor(Math.random() * 0x100000000).toString(16).padStart(8, "0");
+      var lo = Math.floor(Math.random() * 0x10000).toString(16).padStart(4, "0");
+      return hi + lo;
+    }
+
+    function stampOf(el) {
+      var existing = el.getAttribute(STAMP_ATTR);
+      if (existing) return existing;
+      var stamp = nextStamp();
+      el.setAttribute(STAMP_ATTR, stamp);
+      return stamp;
+    }
+
+    // skipSizeCheck exempts <option>/<optgroup> from the zero-size prune: a
+    // closed select's popup is unpainted (0x0) though its options are still
+    // present and pickable. Other visibility rules still apply to them.
+    function isVisible(el, skipSizeCheck) {
+      if (el.hidden) return false;
+      if (el.getAttribute("aria-hidden") === "true") return false;
+      var style;
+      try {
+        style = el.ownerDocument.defaultView.getComputedStyle(el);
+      } catch (e) {
+        style = null;
+      }
+      if (style) {
+        if (style.display === "none" || style.visibility === "hidden") return false;
+      }
+      if (!skipSizeCheck) {
+        var rect = el.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) return false;
+      }
+      return true;
+    }
+
+    function truncate(s) {
+      s = s.trim().replace(/\\s+/g, " ");
+      if (s.length > MAX_NAME_LENGTH) return s.slice(0, MAX_NAME_LENGTH - 1) + "\\u2026";
+      return s;
+    }
+
+    function textOf(el) {
+      return el.textContent || "";
+    }
+
+    function idRefsText(doc, ids) {
+      var parts = [];
+      var list = ids.trim().split(/\\s+/);
+      for (var i = 0; i < list.length; i++) {
+        var ref = doc.getElementById(list[i]);
+        if (ref) parts.push(textOf(ref));
+      }
+      return parts.join(" ").trim();
+    }
+
+    // Text of a <label>, minus any nested form control's own content: a
+    // label that WRAPS its control ("<label>Color <select>...</select></label>")
+    // would otherwise include every option's text in the control's own name.
+    function labelOwnText(label) {
+      var clone = label.cloneNode(true);
+      var controls = clone.querySelectorAll("input, select, textarea, button");
+      for (var i = 0; i < controls.length; i++) {
+        controls[i].parentNode.removeChild(controls[i]);
+      }
+      return textOf(clone);
+    }
+
+    // Guard: without this, an <option> inside a labelled <select> would
+    // inherit the select's own label via closest("label"), not its text.
+    var LABELABLE_TAGS = { INPUT: 1, TEXTAREA: 1, SELECT: 1, BUTTON: 1, METER: 1, OUTPUT: 1, PROGRESS: 1 };
+
+    function nativeLabelText(el) {
+      if (!LABELABLE_TAGS[el.tagName]) return "";
+      var doc = el.ownerDocument;
+      if (el.id) {
+        var forLabel = doc.querySelector('label[for="' + el.id + '"]');
+        if (forLabel) return labelOwnText(forLabel);
+      }
+      var ancestor = el.closest ? el.closest("label") : null;
+      if (ancestor) return labelOwnText(ancestor);
+      return "";
+    }
+
+    // Reduced accname: aria-labelledby, then aria-label, then native label,
+    // then alt/title/placeholder, then trimmed own text for content-named
+    // elements. Not the full W3C accname algorithm (no recursive traversal
+    // rules for nested presentational content) but covers the common cases.
+    function accessibleName(el, contentNamed) {
+      var doc = el.ownerDocument;
+      var labelledby = el.getAttribute("aria-labelledby");
+      if (labelledby) {
+        var viaIds = idRefsText(doc, labelledby);
+        if (viaIds) return truncate(viaIds);
+      }
+      var ariaLabel = el.getAttribute("aria-label");
+      if (ariaLabel && ariaLabel.trim()) return truncate(ariaLabel);
+      var native = nativeLabelText(el);
+      if (native && native.trim()) return truncate(native);
+      var alt = el.getAttribute("alt");
+      if (alt && alt.trim()) return truncate(alt);
+      var title = el.getAttribute("title");
+      if (title && title.trim()) return truncate(title);
+      var placeholder = el.getAttribute("placeholder");
+      if (placeholder && placeholder.trim()) return truncate(placeholder);
+      if (contentNamed) {
+        var text = textOf(el);
+        if (text && text.trim()) return truncate(text);
+      }
+      return "";
+    }
+
+    var IMPLICIT_ROLE_BY_TAG = {
+      A: "link", BUTTON: "button", NAV: "navigation", MAIN: "main", FORM: "form", DIALOG: "dialog",
+      UL: "list", OL: "list", LI: "listitem", TABLE: "table", TR: "row", TD: "cell", TH: "columnheader",
+      SELECT: "combobox", OPTION: "option", TEXTAREA: "textbox", IMG: "img",
+      H1: "heading", H2: "heading", H3: "heading", H4: "heading", H5: "heading", H6: "heading",
+      PROGRESS: "progressbar", METER: "meter"
+    };
+
+    var INPUT_TYPE_ROLE = {
+      button: "button", submit: "button", reset: "button", checkbox: "checkbox", radio: "radio",
+      range: "slider", number: "spinbutton", search: "searchbox", email: "textbox", tel: "textbox",
+      url: "textbox", password: "textbox", text: "textbox", image: "button"
+    };
+
+    var CONTENT_NAMED_ROLES = {
+      button: true, link: true, heading: true, option: true, cell: true,
+      columnheader: true, listitem: true, menuitem: true, tab: true
+    };
+
+    function implicitRole(el) {
+      var explicit = el.getAttribute("role");
+      if (explicit) return explicit;
+      var tag = el.tagName;
+      if (tag === "INPUT") {
+        var type = (el.getAttribute("type") || "text").toLowerCase();
+        return INPUT_TYPE_ROLE[type] || "textbox";
+      }
+      if (tag === "A" && !el.getAttribute("href")) return "";
+      if (Object.prototype.hasOwnProperty.call(IMPLICIT_ROLE_BY_TAG, tag)) {
+        return IMPLICIT_ROLE_BY_TAG[tag];
+      }
+      // Deliberate divergence: Chrome's real AX tree says "generic" here,
+      // but "textbox" is the useful signal an agent needs. Chrome is out of
+      // step, do not "fix" this toward parity.
+      if (el.isContentEditable) return "textbox";
+      return "";
+    }
+
+    function headingLevel(el) {
+      var m = /^H([1-6])$/.exec(el.tagName);
+      return m ? m[1] : null;
+    }
+
+    function currentValue(el) {
+      var tag = el.tagName;
+      if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") {
+        return el.value;
+      }
+      if (el.isContentEditable) return textOf(el);
+      return undefined;
+    }
+
+    function isChecked(el) {
+      var tag = el.tagName;
+      if (tag === "INPUT") {
+        var type = (el.getAttribute("type") || "").toLowerCase();
+        if (type === "checkbox" || type === "radio") return !!el.checked;
+      }
+      var aria = el.getAttribute("aria-checked");
+      if (aria === "true") return true;
+      return false;
+    }
+
+    function describeNode(el, role) {
+      var contentNamed = !!CONTENT_NAMED_ROLES[role];
+      var name = accessibleName(el, contentNamed);
+      var extras = [];
+      var value = currentValue(el);
+      if (value !== undefined && value !== "") extras.push("value=" + JSON.stringify(String(value)));
+      if (isChecked(el)) extras.push("checked=true");
+      if (el.tagName === "OPTION" && el.selected) extras.push("selected");
+      var href = el.getAttribute("href");
+      if (href) extras.push("url=" + href);
+      if (el.disabled || el.getAttribute("aria-disabled") === "true") extras.push("disabled");
+      var level = headingLevel(el);
+      if (level) extras.push("level=" + level);
+      var label = name ? " " + JSON.stringify(name) : "";
+      var extra = extras.length ? " [" + extras.join(" ") + "]" : "";
+      return { role: role, label: label, extra: extra, name: name };
+    }
+
+    // Traverses light DOM, open shadow roots, and same-origin iframe documents.
+    // A cross-origin iframe throws on contentDocument access; caught and
+    // skipped rather than aborting the whole walk, and noted in a comment
+    // here rather than silently vanishing from the tree without a trace.
+    function walk(root, depth) {
+      var children = root.children ? Array.prototype.slice.call(root.children) : [];
+      for (var i = 0; i < children.length; i++) {
+        var el = children[i];
+        var isSelectChild = el.tagName === "OPTION" || el.tagName === "OPTGROUP";
+        if (!isVisible(el, isSelectChild)) continue;
+
+        var role = implicitRole(el);
+        var isLandmarkOrControl = !!role;
+        var described = null;
+        if (isLandmarkOrControl) {
+          described = describeNode(el, role);
+        }
+
+        var hasContent = described && (described.name || described.extra);
+        var isStructural = isLandmarkOrControl && (hasContent || isInteractiveRole(role) || isLandmarkRole(role));
+
+        // Role-less visible leaf text (measured vs Chrome's take_snapshot,
+        // which keeps a StaticText under a generic wrapper for this case,
+        // e.g. a plain status <div>). Only a leaf (no element children, so
+        // its text is not already captured by a nested control/label).
+        var hasElementChildren = !!(el.children && el.children.length > 0);
+        var leafName = !isStructural && !hasElementChildren ? truncate(textOf(el)) : "";
+        var isLeafText = !!leafName;
+
+        var nextDepth = depth;
+        if (isStructural || isLeafText) {
+          var stamp = stampOf(el);
+          var indent = new Array(depth + 1).join("  ");
+          var lineTail = isStructural
+            ? described.role + described.label + described.extra
+            : "text " + JSON.stringify(leafName);
+          lines.push(indent + "[" + stamp + "] " + lineTail);
+          nodeCount += 1;
+          nextDepth = depth + 1;
+        }
+
+        if (el.shadowRoot) {
+          walk(el.shadowRoot, nextDepth);
+        } else if (el.tagName === "IFRAME") {
+          try {
+            var doc = el.contentDocument;
+            if (doc && doc.body) walk(doc.body, nextDepth);
+          } catch (e) {
+            // cross-origin iframe: intentionally skipped, not silently merged
+            // into the parent tree as though it were empty.
+          }
+        } else {
+          walk(el, nextDepth);
+        }
+      }
+    }
+
+    function isInteractiveRole(role) {
+      return (
+        role === "button" ||
+        role === "link" ||
+        role === "textbox" ||
+        role === "searchbox" ||
+        role === "checkbox" ||
+        role === "radio" ||
+        role === "combobox" ||
+        role === "listbox" ||
+        role === "option" ||
+        role === "slider" ||
+        role === "spinbutton" ||
+        role === "progressbar" ||
+        role === "meter"
+      );
+    }
+
+    function isLandmarkRole(role) {
+      return (
+        role === "navigation" ||
+        role === "main" ||
+        role === "form" ||
+        role === "dialog" ||
+        role === "region" ||
+        role === "heading" ||
+        role === "list" ||
+        role === "listitem" ||
+        role === "table" ||
+        role === "row" ||
+        role === "cell" ||
+        role === "columnheader" ||
+        role === "img"
+      );
+    }
+
+    walk(document.body, 0);
+    return { snapshot: lines.join("\\n"), nodeCount: nodeCount };
+  }`;
+}
+var STAMP_ATTR = "data-cdp-uid", MAX_NAME_LENGTH = 120;
+
+// src/client.ts
+class CdpConnection {
+  wsUrl;
+  opts;
+  ws;
+  nextId = 0;
+  pending = new Map;
+  listeners = new Map;
+  closed = false;
+  constructor(wsUrl, opts = {}) {
+    this.wsUrl = wsUrl;
+    this.opts = opts;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.wsUrl);
+      this.ws = ws;
+      const openTimer = setTimeout(() => reject(new CdpError(`connect timeout: ${this.wsUrl}`)), this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS3);
+      ws.onopen = () => {
+        clearTimeout(openTimer);
+        resolve(this);
+      };
+      ws.onerror = (e) => {
+        clearTimeout(openTimer);
+        const msg = e?.message ?? "websocket error";
+        if (this.pending.size === 0)
+          reject(new CdpError(msg));
+        this.rejectAll(new CdpError(msg));
+      };
+      ws.onclose = () => {
+        this.closed = true;
+        this.rejectAll(new CdpError("connection closed"));
+      };
+      ws.onmessage = (ev) => this.onMessage(String(ev.data));
+    });
+  }
+  onMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (typeof msg.id === "number" && this.pending.has(msg.id)) {
+      const p = this.pending.get(msg.id);
+      clearTimeout(p.timer);
+      this.pending.delete(msg.id);
+      p.resolve(msg);
+      return;
+    }
+    if (msg.method) {
+      const set = this.listeners.get(msg.method);
+      if (set)
+        for (const h of set)
+          h(msg.params ?? {}, msg.sessionId);
+      const star = this.listeners.get("*");
+      if (star)
+        for (const h of star)
+          h({ method: msg.method, ...msg.params ?? {} }, msg.sessionId);
+    }
+  }
+  rejectAll(err) {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+  send(method, params = {}, opts = {}) {
+    if (this.closed || !this.ws)
+      return Promise.reject(new CdpError("connection not open"));
+    const id = ++this.nextId;
+    const timeoutMs = opts.timeoutMs ?? this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
+    const payload = { id, method, params };
+    if (opts.sessionId)
+      payload.sessionId = opts.sessionId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new CdpError(`'${method}' timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (r) => {
+          if (r.error)
+            reject(new CdpError(`${method}: ${r.error.message}`, r.error.code, r.error.data));
+          else
+            resolve(r.result ?? {});
+        },
+        reject,
+        timer
+      });
+      this.ws.send(JSON.stringify(payload));
+    });
+  }
+  on(method, handler) {
+    let set = this.listeners.get(method);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(method, set);
+    }
+    set.add(handler);
+    return () => set.delete(handler);
+  }
+  waitFor(method, predicate, timeoutMs = this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS3) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        off();
+        reject(new CdpError(`waitFor('${method}') timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const off = this.on(method, (params) => {
+        if (!predicate || predicate(params)) {
+          clearTimeout(timer);
+          off();
+          resolve(params);
+        }
+      });
+    });
+  }
+  close() {
+    this.closed = true;
+    this.rejectAll(new CdpError("closed by caller"));
+    try {
+      this.ws?.close();
+    } catch {}
+  }
+}
+async function httpJson(path) {
+  const res = await fetch(`${BASE}${path}`);
+  if (!res.ok)
+    throw new CdpError(`${path} -> HTTP ${res.status}`);
+  return await res.json();
+}
+function listTargets() {
+  return httpJson("/json/list");
+}
+async function browserWsUrl() {
+  const v = await httpJson("/json/version");
+  return v.webSocketDebuggerUrl;
+}
+async function resolveTarget(selector, opts = {}) {
+  const targets = await listTargets();
+  const hit = await pickTarget(targets, selector);
+  if (isWorkerTargetType(hit.type))
+    return hit;
+  await assertLeaseOk("chrome", hit.id, { lease: opts.lease, url: hit.url, title: hit.title });
+  return hit;
+}
+async function pickTarget(targets, selector) {
+  const pages = targets.filter((t) => t.type === "page");
+  if (!selector || selector === "active") {
+    if (!pages.length)
+      throw new CdpError("no page targets open");
+    return pages[0];
+  }
+  if (selector.startsWith("index:")) {
+    const i = Number(selector.slice(6));
+    if (!pages[i])
+      throw new CdpError(`no page target at index ${i} (have ${pages.length})`);
+    return pages[i];
+  }
+  if (selector.startsWith("url:")) {
+    const needle = selector.slice(4);
+    const hit = pages.find((t) => t.url.includes(needle));
+    if (!hit)
+      throw new CdpError(`no page url containing '${needle}'`);
+    return hit;
+  }
+  if (selector.startsWith("title:")) {
+    const needle = selector.slice(6);
+    const hit = pages.find((t) => t.title.includes(needle));
+    if (!hit)
+      throw new CdpError(`no page title containing '${needle}'`);
+    return hit;
+  }
+  if (selector.startsWith("label:")) {
+    const label = selector.slice(6);
+    const { matchIds, knownLabels } = await resolveLiveLabel("chrome", label, pages.map((t) => t.id));
+    if (matchIds.length > 1) {
+      throw new CdpError(`label 'label:${label}' matches more than one live target: ${matchIds.join(", ")}. Resolve by target id instead.`);
+    }
+    if (matchIds.length === 1) {
+      const hit = pages.find((t) => t.id === matchIds[0]);
+      if (hit)
+        return hit;
+    }
+    throw new CdpError(knownLabels.length ? `no live target with label '${label}' (labels currently in use: ${knownLabels.join(", ")})` : `no live target with label '${label}' (no labels are currently assigned to any open target)`);
+  }
+  if (isWorkerSelector(selector)) {
+    const needle = workerNeedle(selector);
+    if (needle === "")
+      throw new CdpError(WORKER_EMPTY_NEEDLE_MESSAGE);
+    const { matches, liveWorkers } = resolveWorkerTargets(targets, needle);
+    if (matches.length > 1)
+      throw new CdpError(workerAmbiguityMessage(needle, matches));
+    if (matches.length === 1)
+      return matches[0];
+    throw new CdpError(workerMissMessage(needle, { wakeAttempted: false, liveWorkers }));
+  }
+  const byId = targets.find((t) => t.id === selector);
+  if (!byId)
+    throw new CdpError(`no target with id '${selector}'`);
+  return byId;
+}
+async function openBrowser(opts = {}) {
+  return new CdpConnection(await browserWsUrl(), opts).connect();
+}
+async function openPage(selector, opts = {}) {
+  const target = await resolveTarget(selector, { lease: opts.lease });
+  const conn = await new CdpConnection(target.webSocketDebuggerUrl, opts).connect();
+  return { conn, target };
+}
+async function withPage(selector, fn, opts = {}) {
+  const { conn, target } = await openPage(selector, opts);
+  try {
+    return await fn(conn, target);
+  } finally {
+    conn.close();
+  }
+}
+var BASE, DEFAULT_TIMEOUT_MS3, CdpError;
+var init_client2 = __esm(() => {
+  init_leases();
+  init_origins();
+  init_workers();
+  BASE = process.env.CDP_BASE ?? "http://127.0.0.1:9222";
+  DEFAULT_TIMEOUT_MS3 = Number(process.env.CDP_TIMEOUT_MS ?? 15000);
+  CdpError = class CdpError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+      super(message);
+      this.code = code;
+      this.data = data;
+      this.name = "CdpError";
+    }
+  };
+});
+
+// src/tools/network_mock.ts
+function escapeRegExpChar(ch) {
+  return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+}
+function globToRegExp(pattern) {
+  let re = "";
+  for (let i = 0;i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "\\") {
+      const next = pattern[i + 1];
+      if (next !== undefined) {
+        re += escapeRegExpChar(next);
+        i++;
+      } else {
+        re += "\\\\";
+      }
+    } else if (ch === "*") {
+      re += ".*";
+    } else if (ch === "?") {
+      re += ".";
+    } else {
+      re += escapeRegExpChar(ch);
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+function urlMatches(pattern, url) {
+  return globToRegExp(pattern).test(url);
+}
+function selectRule(rules, url, method) {
+  return rules.find((r) => urlMatches(r.urlPattern, url) && (!r.method || r.method.toUpperCase() === method.toUpperCase()));
+}
+function buildFulfillParams(requestId, rule) {
+  const merged = new Map;
+  merged.set("content-type", { name: "Content-Type", value: rule.contentType ?? "application/json" });
+  for (const [name, value] of Object.entries(rule.headers ?? {})) {
+    merged.set(name.toLowerCase(), { name, value });
+  }
+  return {
+    requestId,
+    responseCode: rule.status ?? 200,
+    responseHeaders: [...merged.values()],
+    body: Buffer.from(rule.body ?? "", "utf8").toString("base64")
+  };
+}
+function effectiveAction(rule, rnd) {
+  if (rule.failRate !== undefined && rule.failRate > 0 && rnd < rule.failRate)
+    return "fail";
+  return rule.action;
+}
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function registerHandler(session) {
+  session.conn.on("Fetch.requestPaused", (params) => {
+    const p = params;
+    session.chain = session.chain.then(async () => {
+      const rule = selectRule(session.rules, p.request.url, p.request.method);
+      if (!rule) {
+        await session.conn.send("Fetch.continueRequest", { requestId: p.requestId });
+        return;
+      }
+      if (rule.delayMs)
+        await delay(rule.delayMs);
+      const act = effectiveAction(rule, Math.random());
+      if (act === "fulfill") {
+        await session.conn.send("Fetch.fulfillRequest", { ...buildFulfillParams(p.requestId, rule) });
+      } else if (act === "fail") {
+        await session.conn.send("Fetch.failRequest", { requestId: p.requestId, errorReason: rule.errorReason ?? "Failed" });
+      } else {
+        await session.conn.send("Fetch.continueRequest", { requestId: p.requestId });
+      }
+      rule.hits++;
+      session.intercepted.push({ url: p.request.url, method: p.request.method, action: act });
+    }).catch((e) => {
+      if (/closed|connection|Target|Inspected/i.test(String(e)))
+        session.dead = true;
+    });
+  });
+}
+async function mockRequest(args) {
+  if (!args.urlPattern)
+    throw new CdpError("mock_request requires a { urlPattern }");
+  const rule = {
+    urlPattern: args.urlPattern,
+    action: args.action ?? "fulfill",
+    status: args.status,
+    body: args.body,
+    contentType: args.contentType,
+    headers: args.headers,
+    errorReason: args.errorReason,
+    method: args.method,
+    delayMs: args.delayMs,
+    failRate: args.failRate,
+    hits: 0
+  };
+  const resolved = await resolveTarget(args.target);
+  let session = sessions.get(resolved.id);
+  if (session && !session.dead) {
+    const idx = session.rules.findIndex((r) => r.urlPattern === rule.urlPattern && (r.method ?? "") === (rule.method ?? ""));
+    if (idx >= 0)
+      session.rules[idx] = rule;
+    else
+      session.rules.push(rule);
+    await session.conn.send("Fetch.enable", { patterns: session.rules.map((r) => ({ urlPattern: r.urlPattern })) });
+  } else {
+    const { conn, target } = await openPage(resolved.id);
+    session = { conn, target, rules: [rule], intercepted: [], chain: Promise.resolve(), dead: false };
+    registerHandler(session);
+    await conn.send("Fetch.enable", { patterns: [{ urlPattern: rule.urlPattern }] });
+    sessions.set(target.id, session);
+  }
+  let reloaded = false;
+  if (args.reload) {
+    await session.conn.send("Page.enable");
+    await session.conn.send("Page.reload", { ignoreCache: true });
+    await delay(800);
+    reloaded = true;
+  }
+  return {
+    target: { id: session.target.id, url: session.target.url, title: session.target.title },
+    pattern: rule.urlPattern,
+    ruleCount: session.rules.length,
+    reloaded
+  };
+}
+async function listMocks(_args = {}) {
+  for (const [id, s] of sessions) {
+    if (s.dead) {
+      try {
+        s.conn.close();
+      } catch {}
+      sessions.delete(id);
+      continue;
+    }
+    try {
+      await s.conn.send("Runtime.evaluate", { expression: "1", returnByValue: true }, { timeoutMs: 3000 });
+    } catch {
+      try {
+        s.conn.close();
+      } catch {}
+      sessions.delete(id);
+    }
+  }
+  const mocks = [...sessions.values()].map((s) => ({
+    target: { id: s.target.id, url: s.target.url, title: s.target.title },
+    rules: s.rules.map((r) => ({ urlPattern: r.urlPattern, action: r.action, method: r.method, hits: r.hits })),
+    hits: s.intercepted.length
+  }));
+  return { count: mocks.length, mocks };
+}
+async function clearMocks(args = {}) {
+  let ids;
+  if (args.all) {
+    ids = [...sessions.keys()];
+  } else {
+    const resolved = await resolveTarget(args.target);
+    ids = sessions.has(resolved.id) ? [resolved.id] : [];
+  }
+  let cleared = 0;
+  for (const id of ids) {
+    const s = sessions.get(id);
+    if (!s)
+      continue;
+    try {
+      await s.conn.send("Fetch.disable");
+    } catch {}
+    try {
+      s.conn.close();
+    } catch {}
+    sessions.delete(id);
+    cleared++;
+  }
+  return { cleared };
+}
+var sessions;
+var init_network_mock = __esm(() => {
+  init_client2();
+  sessions = new Map;
+});
+
+// src/bidi/driver.ts
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+function normalizeBidiCookie(c) {
+  const value = c.value.type === "base64" ? Buffer.from(c.value.value, "base64").toString("utf8") : c.value.value;
+  const hasExpiry = typeof c.expiry === "number";
+  return {
+    name: c.name,
+    value,
+    domain: c.domain,
+    path: c.path,
+    expires: hasExpiry ? c.expiry : -1,
+    size: typeof c.size === "number" ? c.size : Buffer.byteLength(`${c.name}${value}`, "utf8"),
+    httpOnly: c.httpOnly === true,
+    secure: c.secure === true,
+    sameSite: c.sameSite ?? "default",
+    session: !hasExpiry
+  };
+}
+function hostFromUrl(url, toolName) {
+  if (url === undefined || url === "") {
+    throw driverError("unsupported", `${toolName} on Firefox needs a 'domain': BiDi's storage cookie calls have no 'url' parameter, and no url was given to derive one from.`);
+  }
+  let host = "";
+  try {
+    host = new URL(url).hostname;
+  } catch {
+    throw driverError("unsupported", `${toolName} could not parse the url '${url}' to derive the 'domain' BiDi requires. Pass 'domain' explicitly.`);
+  }
+  if (host === "") {
+    throw driverError("unsupported", `${toolName} cannot derive a 'domain' from '${url}': that url has no host. Pass 'domain' explicitly.`);
+  }
+  return host;
+}
+function driverError(code, message, data) {
+  return Object.assign(new Error(message), { code, ...data !== undefined ? { data } : {} });
+}
+function encodeUid(stamp) {
+  return `bidi:${stamp}`;
+}
+function decodeStamp(uid) {
+  if (!uid.startsWith("bidi:"))
+    throw driverError("foreign-uid", `uid is not owned by the bidi driver: ${uid}`);
+  const payload = uid.slice(5);
+  if (!payload.length)
+    throw driverError("foreign-uid", `malformed bidi uid payload: ${uid}`);
+  return payload;
+}
+function cssEscape(s) {
+  return s.replace(/["\\]/g, (c) => `\\${c}`);
+}
+function mapBidiError(e) {
+  if (e instanceof BidiError) {
+    const code = e.code;
+    if (code === "no such node" || code === "no such element")
+      return driverError("no-such-element", e.message);
+    if (code === "no such frame")
+      return driverError("no-such-target", e.message);
+    if (code === "invalid session id")
+      return driverError("disconnected", e.message);
+    if (code === "unsupported operation")
+      return driverError("unsupported", e.message);
+    if (!code && /timed out/i.test(e.message))
+      return driverError("timeout", e.message);
+    if (!code && /(disposed|not open|connection closed)/i.test(e.message))
+      return driverError("disconnected", e.message);
+    if (/NS_ERROR_FILE_ACCESS_DENIED/i.test(e.message)) {
+      return driverError("page-error", `${e.message} — the browser process was not allowed to open this file:// path. For a snap- or AppArmor-confined Firefox (Ubuntu default) that is kernel-level and no preference fixes it: serve the directory over a local http server (e.g. python3 -m http.server) and navigate to the http://127.0.0.1:<port>/ URL instead. If this Firefox was launched by cdp-toolkit and still fails, please report it at https://github.com/sblattj/cdp-toolkit/issues.`);
+    }
+    return driverError("page-error", e.message);
+  }
+  return driverError("page-error", e instanceof Error ? e.message : String(e));
+}
+function serializeArg(v) {
+  if (v === undefined)
+    return { type: "undefined" };
+  if (v === null)
+    return { type: "null" };
+  if (typeof v === "string")
+    return { type: "string", value: v };
+  if (typeof v === "number")
+    return { type: "number", value: Number.isNaN(v) ? "NaN" : v };
+  if (typeof v === "boolean")
+    return { type: "boolean", value: v };
+  if (Array.isArray(v))
+    return { type: "array", value: v.map(serializeArg) };
+  if (typeof v === "object")
+    return { type: "object", value: Object.entries(v).map(([k, val]) => [k, serializeArg(val)]) };
+  return { type: "string", value: String(v) };
+}
+function deserializeRemote(rv) {
+  switch (rv.type) {
+    case "undefined":
+      return;
+    case "null":
+      return null;
+    case "string":
+      return rv.value;
+    case "boolean":
+      return rv.value;
+    case "bigint":
+      return rv.value;
+    case "number":
+      return typeof rv.value === "number" ? rv.value : rv.value;
+    case "array":
+      return (rv.value ?? []).map(deserializeRemote);
+    case "object": {
+      const out = {};
+      for (const [k, v] of rv.value ?? [])
+        out[typeof k === "string" ? k : String(deserializeRemote(k))] = deserializeRemote(v);
+      return out;
+    }
+    case "node":
+      return { bidiSharedId: rv.sharedId };
+    default:
+      return;
+  }
+}
+function exceptionMessage(d) {
+  if (d.text)
+    return d.text;
+  const ex = deserializeRemote(d.exception);
+  return typeof ex === "string" ? ex : "evaluation threw";
+}
+function splitExtras(s) {
+  const out = [];
+  let cur = "";
+  let inQuotes = false;
+  for (let i = 0;i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '"' && s[i - 1] !== "\\")
+      inQuotes = !inQuotes;
+    if (ch === " " && !inQuotes) {
+      if (cur)
+        out.push(cur);
+      cur = "";
+    } else
+      cur += ch;
+  }
+  if (cur)
+    out.push(cur);
+  return out;
+}
+function parseSnapshotLine(line) {
+  const m = LINE_RE.exec(line);
+  if (!m)
+    return;
+  const indent = m[1] ?? "", stamp = m[2], role = m[3], nameLit = m[4], extrasRaw = m[5];
+  const depth = indent.length / 2;
+  let name;
+  if (nameLit) {
+    try {
+      name = JSON.parse(nameLit);
+    } catch {
+      name = nameLit;
+    }
+  }
+  const extras = {};
+  if (extrasRaw) {
+    for (const tok of splitExtras(extrasRaw)) {
+      const eq = tok.indexOf("=");
+      if (eq === -1) {
+        extras[tok] = "true";
+        continue;
+      }
+      const key = tok.slice(0, eq);
+      let val = tok.slice(eq + 1);
+      if (val.startsWith('"')) {
+        try {
+          val = JSON.parse(val);
+        } catch {}
+      }
+      extras[key] = val;
+    }
+  }
+  return { uid: encodeUid(stamp), role, depth, ...name !== undefined ? { name } : {}, ...Object.keys(extras).length ? { extras } : {} };
+}
+async function locateNodes(conn, contextId, locator) {
+  try {
+    const { nodes } = await conn.send("browsingContext.locateNodes", { context: contextId, locator, maxNodeCount: 1 });
+    return nodes;
+  } catch (e) {
+    throw mapBidiError(e);
+  }
+}
+function sharedRefOf(node, describe) {
+  if (!node.sharedId)
+    throw driverError("page-error", `located node has no sharedId (${describe})`);
+  return { sharedId: node.sharedId };
+}
+async function resolveElementLocator(conn, contextId, loc) {
+  if ("uid" in loc) {
+    const stamp = decodeStamp(loc.uid);
+    const nodes = await locateNodes(conn, contextId, { type: "css", value: `[${UID_STAMP_ATTR}="${cssEscape(stamp)}"]` });
+    if (!nodes.length)
+      throw driverError("stale-uid", `uid does not resolve: ${loc.uid}`);
+    return sharedRefOf(nodes[0], loc.uid);
+  }
+  if ("css" in loc) {
+    const nodes = await locateNodes(conn, contextId, { type: "css", value: loc.css });
+    if (!nodes.length)
+      throw driverError("no-such-element", `css '${loc.css}' matched no element`);
+    return sharedRefOf(nodes[0], `css '${loc.css}'`);
+  }
+  if ("xpath" in loc) {
+    const nodes = await locateNodes(conn, contextId, { type: "xpath", value: loc.xpath });
+    if (!nodes.length)
+      throw driverError("no-such-element", `xpath '${loc.xpath}' matched no element`);
+    return sharedRefOf(nodes[0], `xpath '${loc.xpath}'`);
+  }
+  const nodes = await locateNodes(conn, contextId, { type: "innerText", value: loc.text, matchType: "partial" });
+  if (!nodes.length)
+    throw driverError("no-such-element", `text '${loc.text}' matched no element`);
+  return sharedRefOf(nodes[0], `text '${loc.text}'`);
+}
+function bumpEpoch(endpoint, conn) {
+  sessionEpochs.set(endpoint, (sessionEpochs.get(endpoint) ?? 0) + 1);
+  connEndpoints.set(conn, endpoint);
+}
+function withStaleIdHint(conn, err) {
+  const endpoint = connEndpoints.get(conn);
+  if (endpoint === undefined)
+    return err;
+  if ((sessionEpochs.get(endpoint) ?? 0) <= 1)
+    return err;
+  const e = err;
+  if (!isDriverError(e) || e.code !== "no-such-target")
+    return err;
+  if (e.message.includes("re-established"))
+    return err;
+  e.message += STALE_ID_HINT;
+  return e;
+}
+function muxMode(attached) {
+  const raw = process.env.CDP_FIREFOX_MUX;
+  if (raw === "off")
+    return "off";
+  if (raw === "host")
+    return "host";
+  if (raw === "daemon")
+    return "daemon";
+  return attached ? "daemon" : "host";
+}
+function resolveDaemonScript() {
+  const override = process.env.CDP_FIREFOX_MUX_DAEMON;
+  if (override)
+    return override;
+  for (const rel of ["./mux-daemon.ts", "./mux-daemon.js", "./bidi/mux-daemon.js", "../bidi/mux-daemon.js"]) {
+    let p;
+    try {
+      p = fileURLToPath(new URL(rel, import.meta.url));
+    } catch {
+      continue;
+    }
+    if (existsSync(p))
+      return p;
+  }
+  return;
+}
+async function liveAdvertisedHolder(endpoint) {
+  const rec = await readSessionSlot(endpoint).catch(() => {
+    return;
+  });
+  if (!rec || !rec.muxEndpoint || !isPidAlive(rec.pid))
+    return;
+  return { endpoint: rec.muxEndpoint, holder: rec };
+}
+async function ensureMuxDaemon(endpoint) {
+  const already = await liveAdvertisedHolder(endpoint);
+  if (already)
+    return already;
+  const script = resolveDaemonScript();
+  if (!script)
+    return;
+  let exited = false;
+  const child = spawn(process.execPath, [script, endpoint, String(process.pid)], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, CDP_FIREFOX_MUX: "host" }
+  });
+  child.once("error", () => {
+    exited = true;
+  });
+  child.once("exit", () => {
+    exited = true;
+  });
+  child.unref();
+  const deadline = Date.now() + sessionWaitMs() + 5000;
+  while (Date.now() < deadline) {
+    const hit = await liveAdvertisedHolder(endpoint);
+    if (hit)
+      return hit;
+    if (exited)
+      return;
+    await sleep2(50);
+  }
+  throw driverError("disconnected", `Firefox's single WebDriver BiDi session on ${endpoint} could not be brought up: a mux daemon was ` + `spawned (${script}) but never advertised a multiplexer within ${sessionWaitMs() + 5000}ms. ` + `Its diagnostics are in ${muxDaemonLogFile(endpoint)}. Retry, or set CDP_FIREFOX_MUX=host to run ` + `the session in this process instead.`);
+}
+async function releaseSlotOnDialFailure(endpoint, owned) {
+  if (owned)
+    return;
+  const h = slotHandles.get(endpoint);
+  if (h) {
+    await releaseSessionSlot(h).catch(() => {
+      return;
+    });
+    slotHandles.delete(endpoint);
+  }
+}
+function orphanNotClearedError(endpoint) {
+  return driverError("disconnected", `Firefox holds an orphaned WebDriver BiDi session on ${endpoint} that could not be auto-cleared. ` + `Marionette recovery needs Firefox launched with --marionette (default port 2828, or set ` + `CDP_FIREFOX_MARIONETTE_PORT); otherwise restart Firefox to free the slot. (A client killed without ` + `session.end can leave a session Firefox does not reap.)`);
+}
+async function getConnection(endpoint, timeoutMs, attached = false) {
+  const existing = connections.get(endpoint);
+  if (existing && existing.isOpen) {
+    existing.retain();
+    return existing;
+  }
+  if (existing)
+    connections.delete(endpoint);
+  const inflight = connecting.get(endpoint);
+  if (inflight) {
+    const conn = await inflight;
+    conn.retain();
+    return conn;
+  }
+  const create = (async () => {
+    const mport = defaultMarionettePort();
+    const dialOpts = {
+      ...timeoutMs !== undefined ? { timeoutMs } : {},
+      capabilities: { alwaysMatch: { unhandledPromptBehavior: { default: "ignore" } } }
+    };
+    let owned = slotHandles.has(endpoint);
+    if (joined.has(endpoint)) {
+      joined.delete(endpoint);
+      owned = false;
+    }
+    if (!owned && muxMode(attached) === "daemon") {
+      const target = await ensureMuxDaemon(endpoint);
+      if (target) {
+        try {
+          const joinedConn = await connectBidiSessionUrl(target.endpoint, dialOpts);
+          connections.set(endpoint, joinedConn);
+          joined.add(endpoint);
+          bumpEpoch(endpoint, joinedConn);
+          return joinedConn;
+        } catch (e) {
+          console.error(`[cdp-toolkit] firefox mux daemon at ${target.endpoint} could not be dialed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      }
+    }
+    for (let attempt = 0;; attempt++) {
+      if (owned)
+        break;
+      let acq;
+      try {
+        acq = await acquireSessionSlot(endpoint, { label: slotLabelOverride ?? defaultLabel(), marionettePort: mport });
+      } catch (e) {
+        if (e instanceof SessionSlotBusyError) {
+          const who = e.holderLabel ? `'${e.holderLabel}' (pid ${e.holderPid})` : "another live process";
+          throw driverError("disconnected", `Firefox's single WebDriver BiDi session on ${endpoint} is held by a LIVE process ${who}. ` + `Firefox serves exactly ONE BiDi session per browser instance, so this server cannot take it ` + `while that process is running. Wait for it to release the session and retry, or point this ` + `server at a different endpoint/browser.`);
+        }
+        throw e;
+      }
+      if (acq.joinMux) {
+        const { endpoint: muxEndpoint, holder } = acq.joinMux;
+        try {
+          const joinedConn = await connectBidiSessionUrl(muxEndpoint, dialOpts);
+          connections.set(endpoint, joinedConn);
+          joined.add(endpoint);
+          bumpEpoch(endpoint, joinedConn);
+          return joinedConn;
+        } catch (e) {
+          if (attempt === 0)
+            continue;
+          const who = `'${holder.label}' (pid ${holder.pid})`;
+          throw driverError("disconnected", `Firefox's single WebDriver BiDi session on ${endpoint} is held by a LIVE process ${who}, ` + `which advertises a BiDi multiplexer at ${muxEndpoint}, but that multiplexer could not be ` + `dialed (${e instanceof Error ? e.message : String(e)}). The holder is most likely shutting ` + `down; retry in a moment, or point this server at a different endpoint/browser.`);
+        }
+      }
+      if (acq.handle)
+        slotHandles.set(endpoint, acq.handle);
+      if (acq.staleHolder) {
+        await forceClearOrphanSession(acq.staleHolder.marionettePort ?? mport);
+      }
+      break;
+    }
+    let conn;
+    try {
+      conn = await connectBidiSessionUrl(endpoint, dialOpts);
+    } catch (e) {
+      if (e instanceof BidiError && /maximum number of active sessions/i.test(e.message)) {
+        const cleared = await forceClearOrphanSession(mport);
+        if (!cleared) {
+          await releaseSlotOnDialFailure(endpoint, owned);
+          throw orphanNotClearedError(endpoint);
+        }
+        try {
+          conn = await connectBidiSessionUrl(endpoint, dialOpts);
+        } catch (e2) {
+          await releaseSlotOnDialFailure(endpoint, owned);
+          if (e2 instanceof BidiError && /maximum number of active sessions/i.test(e2.message)) {
+            throw orphanNotClearedError(endpoint);
+          }
+          throw e2;
+        }
+      } else {
+        await releaseSlotOnDialFailure(endpoint, owned);
+        throw e;
+      }
+    }
+    connections.set(endpoint, conn);
+    bumpEpoch(endpoint, conn);
+    if (muxMode(attached) !== "off") {
+      try {
+        const mux = await startBidiMux(conn);
+        muxes.set(endpoint, mux);
+        const h = slotHandles.get(endpoint);
+        if (h)
+          await advertiseMux(h, mux.endpoint);
+      } catch (e) {
+        console.error(`[cdp-toolkit] firefox mux not started: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    return conn;
+  })();
+  connecting.set(endpoint, create);
+  try {
+    return await create;
+  } finally {
+    connecting.delete(endpoint);
+  }
+}
+async function safeTitle(conn, contextId) {
+  try {
+    const res = await conn.send("script.evaluate", { expression: "document.title", target: { context: contextId }, awaitPromise: false });
+    return res.type === "success" && res.result.type === "string" ? res.result.value : "";
+  } catch {
+    return "";
+  }
+}
+async function pageInfoOf(conn, ctx) {
+  return { id: ctx.context, url: ctx.url, title: await safeTitle(conn, ctx.context) };
+}
+async function resolveContext(conn, selector, opts = {}) {
+  const { contexts } = await conn.send("browsingContext.getTree", {}).catch((e) => {
+    throw mapBidiError(e);
+  });
+  if (!contexts.length)
+    throw driverError("no-such-target", "no browsing contexts available");
+  const hit = await pickContext(conn, contexts, selector).catch((e) => {
+    throw withStaleIdHint(conn, e);
+  });
+  await assertLeaseOk("firefox", hit.context, { lease: opts.lease, url: hit.url });
+  return hit;
+}
+async function pickContext(conn, contexts, selector) {
+  if (selector === undefined || selector === "active")
+    return contexts[0];
+  if (selector.startsWith("index:")) {
+    const t = contexts[Number(selector.slice(6))];
+    if (!t)
+      throw driverError("no-such-target", `no context at ${selector}`);
+    return t;
+  }
+  if (selector.startsWith("url:")) {
+    const needle = selector.slice(4);
+    const t = contexts.find((c) => c.url.includes(needle));
+    if (!t)
+      throw driverError("no-such-target", `no context with url containing '${needle}'`);
+    return t;
+  }
+  if (selector.startsWith("title:")) {
+    const needle = selector.slice(6);
+    for (const c of contexts)
+      if ((await safeTitle(conn, c.context)).includes(needle))
+        return c;
+    throw driverError("no-such-target", `no context with title containing '${needle}'`);
+  }
+  if (selector.startsWith("label:")) {
+    const label = selector.slice(6);
+    const { matchIds, knownLabels } = await resolveLiveLabel("firefox", label, contexts.map((c) => c.context));
+    if (matchIds.length > 1) {
+      throw driverError("no-such-target", `label 'label:${label}' matches more than one live target: ${matchIds.join(", ")}. Resolve by target id instead.`);
+    }
+    if (matchIds.length === 1) {
+      const hit = contexts.find((c) => c.context === matchIds[0]);
+      if (hit)
+        return hit;
+    }
+    throw driverError("no-such-target", knownLabels.length ? `no live target with label '${label}' (labels currently in use: ${knownLabels.join(", ")})` : `no live target with label '${label}' (no labels are currently assigned to any open target)`);
+  }
+  if (isWorkerSelector(selector)) {
+    throw driverError("unsupported", WORKER_SELECTOR_UNSUPPORTED_MESSAGE);
+  }
+  const exact = contexts.find((c) => c.context === selector);
+  if (exact)
+    return exact;
+  throw driverError("no-such-target", `no context matching '${selector}'`);
+}
+
+class BidiBrowserDriver {
+  endpoint;
+  timeoutMs;
+  attached;
+  scheme = "bidi";
+  lifetime = "session";
+  capabilities = BIDI_CAPABILITIES;
+  uidStability = "document-stamp";
+  snapshotFidelity = "dom-heuristic";
+  constructor(endpoint, timeoutMs, attached = false) {
+    this.endpoint = endpoint;
+    this.timeoutMs = timeoutMs;
+    this.attached = attached;
+  }
+  async listPages() {
+    const conn = await getConnection(this.endpoint, this.timeoutMs, this.attached);
+    try {
+      const { contexts } = await conn.send("browsingContext.getTree", {}).catch((e) => {
+        throw mapBidiError(e);
+      });
+      return Promise.all(contexts.map((c) => pageInfoOf(conn, c)));
+    } finally {
+      conn.release();
+    }
+  }
+  async newPage(url) {
+    const conn = await getConnection(this.endpoint, this.timeoutMs, this.attached);
+    try {
+      const { context } = await conn.send("browsingContext.create", { type: "tab" }).catch((e) => {
+        throw mapBidiError(e);
+      });
+      if (url)
+        await conn.send("browsingContext.navigate", { context, url, wait: "complete" }).catch((e) => {
+          throw mapBidiError(e);
+        });
+      return { id: context, url: url ?? "about:blank", title: await safeTitle(conn, context) };
+    } finally {
+      conn.release();
+    }
+  }
+  async closePage(id) {
+    const conn = await getConnection(this.endpoint, this.timeoutMs, this.attached);
+    try {
+      await conn.send("browsingContext.close", { context: id }).catch((e) => {
+        throw mapBidiError(e);
+      });
+      return { success: true };
+    } finally {
+      conn.release();
+    }
+  }
+  async activatePage(id) {
+    const conn = await getConnection(this.endpoint, this.timeoutMs, this.attached);
+    try {
+      await conn.send("browsingContext.activate", { context: id }).catch((e) => {
+        throw mapBidiError(e);
+      });
+      const ctx = await resolveContext(conn, id);
+      return await pageInfoOf(conn, ctx);
+    } finally {
+      conn.release();
+    }
+  }
+  async page(selector) {
+    const conn = await getConnection(this.endpoint, this.timeoutMs, this.attached);
+    let ctx;
+    try {
+      ctx = await resolveContext(conn, selector);
+    } catch (e) {
+      conn.release();
+      throw e;
+    }
+    const info = await pageInfoOf(conn, ctx);
+    return new BidiPageDriver(conn, ctx.context, info, this);
+  }
+  async installActivityBeacon(contextId) {
+    const conn = await getConnection(this.endpoint, this.timeoutMs, this.attached).catch(() => {
+      return;
+    });
+    if (!conn)
+      return false;
+    try {
+      const key = `${this.endpoint}:${contextId}`;
+      if (!bidiBeaconScripts.has(key)) {
+        const registered = await conn.send("script.addPreloadScript", {
+          functionDeclaration: BEACON_FUNCTION_DECLARATION,
+          contexts: [contextId]
+        });
+        bidiBeaconScripts.set(key, registered.script);
+      }
+      await conn.send("script.evaluate", {
+        expression: BEACON_SOURCE,
+        target: { context: contextId },
+        awaitPromise: false
+      });
+      return true;
+    } catch {
+      return false;
+    } finally {
+      conn.release();
+    }
+  }
+  async readActivityBeacon(contextId) {
+    const conn = await getConnection(this.endpoint, this.timeoutMs, this.attached).catch(() => {
+      return;
+    });
+    if (!conn)
+      return null;
+    try {
+      const res = await conn.send("script.evaluate", {
+        expression: BEACON_READ_EXPRESSION,
+        target: { context: contextId },
+        awaitPromise: false
+      });
+      if (res.type !== "success")
+        return null;
+      const value = deserializeRemote(res.result);
+      return typeof value === "number" && Number.isFinite(value) ? value : null;
+    } catch {
+      return null;
+    } finally {
+      conn.release();
+    }
+  }
+  async dispose() {
+    for (const key of [...bidiBeaconScripts.keys()]) {
+      if (key.startsWith(`${this.endpoint}:`))
+        bidiBeaconScripts.delete(key);
+    }
+    connecting.delete(this.endpoint);
+    const mux = muxes.get(this.endpoint);
+    if (mux) {
+      muxes.delete(this.endpoint);
+      await mux.close().catch(() => {
+        return;
+      });
+    }
+    const conn = connections.get(this.endpoint);
+    if (!conn) {
+      joined.delete(this.endpoint);
+      await this.releaseSessionSlotIfHeld();
+      return;
+    }
+    connections.delete(this.endpoint);
+    if (joined.has(this.endpoint)) {
+      joined.delete(this.endpoint);
+      conn.dispose();
+      return;
+    }
+    await conn.send("session.end", {}).catch(() => {
+      return;
+    });
+    conn.dispose();
+    await this.releaseSessionSlotIfHeld();
+  }
+  async releaseSessionSlotIfHeld() {
+    const h = slotHandles.get(this.endpoint);
+    if (!h)
+      return;
+    await releaseSessionSlot(h).catch(() => {
+      return;
+    });
+    slotHandles.delete(this.endpoint);
+  }
+}
+function createFirefoxDriver(port, opts) {
+  return new BidiBrowserDriver(`ws://127.0.0.1:${port}/session`, opts?.timeoutMs);
+}
+async function hostFirefoxMux(endpoint, opts = {}) {
+  if (opts.label)
+    slotLabelOverride = opts.label;
+  if (process.env.CDP_FIREFOX_MUX !== "host") {
+    throw new Error("hostFirefoxMux requires CDP_FIREFOX_MUX=host (set it before importing this module)");
+  }
+  const conn = await getConnection(endpoint, undefined, true);
+  if (joined.has(endpoint)) {
+    joined.delete(endpoint);
+    connections.delete(endpoint);
+    conn.dispose();
+    throw new Error(`endpoint ${endpoint} is already served by another holder's multiplexer`);
+  }
+  const mux = muxes.get(endpoint);
+  if (!mux) {
+    const driver = new BidiBrowserDriver(endpoint, undefined, true);
+    await driver.dispose().catch(() => {
+      return;
+    });
+    throw new Error(`could not start a BiDi multiplexer for ${endpoint}`);
+  }
+  const driver = new BidiBrowserDriver(endpoint, undefined, true);
+  return {
+    mux,
+    conn,
+    dispose: () => driver.dispose()
+  };
+}
+function createFirefoxDriverForEndpoint(wsUrl, opts) {
+  return new BidiBrowserDriver(wsUrl, opts?.timeoutMs, true);
+}
+var LINE_RE, INTERACTIVE_ROLES, STAMP_ONE_SOURCE, KEY_VALUES, MODIFIER_VALUES, BUTTON_CODES, ARM_SCROLL_SETTLE_WATCH_SOURCE, AWAIT_SCROLL_SETTLE_SOURCE = "function(){return window.__cdpScrollSettle;}", BIDI_CAPABILITIES, connections, slotHandles, muxes, joined, connecting, sessionEpochs, connEndpoints, STALE_ID_HINT, sleep2 = (ms) => new Promise((r) => setTimeout(r, ms)), slotLabelOverride, bidiBeaconScripts, BidiPageDriver;
+var init_driver2 = __esm(() => {
+  init_driver();
+  init_leases();
+  init_origins();
+  init_workers();
+  init_activity();
+  init_client();
+  init_session_lease();
+  init_mux();
+  init_marionette();
+  init_network_mock();
+  LINE_RE = /^((?: {2})*)\[([0-9a-f]+)\] ([a-zA-Z_][\w-]*)(?: ("(?:[^"\\]|\\.)*"))?(?: \[(.*)\])?$/;
+  INTERACTIVE_ROLES = new Set([
+    "button",
+    "link",
+    "textbox",
+    "searchbox",
+    "checkbox",
+    "radio",
+    "combobox",
+    "listbox",
+    "option",
+    "slider",
+    "spinbutton",
+    "progressbar",
+    "meter"
+  ]);
+  STAMP_ONE_SOURCE = `function(){var a=${JSON.stringify(UID_STAMP_ATTR)};var e=this.getAttribute(a);if(e)return e;var s=Math.floor(Math.random()*0x100000000).toString(16).padStart(8,"0")+Math.floor(Math.random()*0x10000).toString(16).padStart(4,"0");this.setAttribute(a,s);return s;}`;
+  KEY_VALUES = {
+    enter: "",
+    return: "",
+    tab: "",
+    escape: "",
+    esc: "",
+    backspace: "",
+    delete: "",
+    space: " ",
+    arrowup: "",
+    arrowdown: "",
+    arrowleft: "",
+    arrowright: "",
+    up: "",
+    down: "",
+    left: "",
+    right: "",
+    home: "",
+    end: "",
+    pageup: "",
+    pagedown: ""
+  };
+  MODIFIER_VALUES = { shift: "", control: "", ctrl: "", alt: "", meta: "", cmd: "", command: "" };
+  BUTTON_CODES = { left: 0, middle: 1, right: 2 };
+  ARM_SCROLL_SETTLE_WATCH_SOURCE = "function(){window.__cdpScrollSettle=new Promise((resolve)=>{let t;const done=()=>{window.removeEventListener('scroll',on,true);resolve(true);};" + "const on=()=>{clearTimeout(t);t=setTimeout(done,60);};window.addEventListener('scroll',on,true);t=setTimeout(done,60);setTimeout(done,500);});}";
+  BIDI_CAPABILITIES = new Set([
+    "emulate.deviceMetrics",
+    "screenshot.fullPage",
+    "screenshot.element",
+    "screenshot.renderSize",
+    "network.intercept",
+    "locate.xpath"
+  ]);
+  connections = new Map;
+  slotHandles = new Map;
+  muxes = new Map;
+  joined = new Set;
+  connecting = new Map;
+  sessionEpochs = new Map;
+  connEndpoints = new WeakMap;
+  STALE_ID_HINT = " — the Firefox BiDi session was re-established after its previous holder went away, and Firefox " + "assigns new context ids per session — re-resolve the tab with list_pages (url:/title: selectors) " + "and claim it again";
+  bidiBeaconScripts = new Map;
+  BidiPageDriver = class BidiPageDriver {
+    conn;
+    contextId;
+    info;
+    browser;
+    released = false;
+    bodyCollector;
+    constructor(conn, contextId, info, browser) {
+      this.conn = conn;
+      this.contextId = contextId;
+      this.info = info;
+      this.browser = browser;
+    }
+    async urlAndReadyState() {
+      const raw = await this.conn.send("script.evaluate", {
+        expression: "location.href + '\\u0000' + document.readyState",
+        target: { context: this.contextId },
+        awaitPromise: false
+      }).then((r) => r.type === "success" ? String(deserializeRemote(r.result) ?? "") : "").catch(() => "");
+      const [url = "", ready = ""] = raw.split("\x00");
+      return [url, ready];
+    }
+    async settleAfterTraversal(beforeUrl, waitUntil, timeoutMs) {
+      const ready = waitUntil === "domcontentloaded" ? ["interactive", "complete"] : ["complete"];
+      const deadline = Date.now() + timeoutMs;
+      for (;; ) {
+        const [url, state] = await this.urlAndReadyState();
+        if (url && url !== beforeUrl && ready.includes(state))
+          return { waitedFor: waitUntil, url };
+        if (Date.now() >= deadline)
+          return { waitedFor: "timeout", url: url || beforeUrl };
+        await new Promise((r) => setTimeout(r, 50));
+      }
+    }
+    async navigate(opts) {
+      const reload = opts.reload === true;
+      const history = opts.history;
+      if (!reload && !history && !opts.url)
+        throw driverError("page-error", "navigate: 'url' is required unless reload:true");
+      const waitUntil = opts.waitUntil ?? "load";
+      const wait = waitUntil === "domcontentloaded" ? "interactive" : "complete";
+      const sendOpts = opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {};
+      try {
+        if (reload) {
+          if (opts.ignoreCache === true) {
+            throw driverError("unsupported", "navigate: ignoreCache:true (hard reload) is not supported on the Firefox WebDriver-BiDi backend — Firefox rejects the ignoreCache argument outright. A plain reload (reload:true, no ignoreCache) works.");
+          }
+          const r = await this.conn.send("browsingContext.reload", { context: this.contextId, wait }, sendOpts);
+          return { url: r.url, contextId: this.contextId, reloaded: true, waitedFor: waitUntil };
+        }
+        if (history) {
+          const [beforeUrl] = await this.urlAndReadyState();
+          await this.conn.send("browsingContext.traverseHistory", { context: this.contextId, delta: history === "back" ? -1 : 1 }, sendOpts).catch((e) => {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (/no such history entry|history/i.test(msg))
+              throw driverError("page-error", `navigate: no history entry to go ${history} to (${msg})`);
+            throw e;
+          });
+          const settled = await this.settleAfterTraversal(beforeUrl, waitUntil, opts.timeoutMs ?? 15000);
+          return { url: settled.url, contextId: this.contextId, traversed: history, waitedFor: settled.waitedFor };
+        }
+        const r = await this.conn.send("browsingContext.navigate", { context: this.contextId, url: opts.url, wait }, sendOpts);
+        return { url: r.url, contextId: this.contextId, waitedFor: waitUntil };
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+    }
+    async waitForText(text, timeoutMs = 15000, pollMs = 250) {
+      const start = Date.now();
+      const expr = `(() => { const b = document.body; return !!b && typeof b.innerText === 'string' && b.innerText.includes(${JSON.stringify(text)}); })()`;
+      for (;; ) {
+        const found = await this.conn.send("script.evaluate", { expression: expr, target: { context: this.contextId }, awaitPromise: true }).then((r) => r.type === "success" && deserializeRemote(r.result) === true).catch(() => false);
+        if (found)
+          return { found: true, elapsedMs: Date.now() - start };
+        if (Date.now() - start >= timeoutMs)
+          throw driverError("timeout", `waitForText: '${text}' not found within ${timeoutMs}ms`);
+        await new Promise((r) => setTimeout(r, Math.min(pollMs, Math.max(0, timeoutMs - (Date.now() - start)))));
+      }
+    }
+    async callFunctionValue(functionDeclaration, args, thisRef) {
+      try {
+        const res = await this.conn.send("script.callFunction", {
+          functionDeclaration,
+          awaitPromise: true,
+          target: { context: this.contextId },
+          arguments: args.map(serializeArg),
+          ...thisRef ? { this: thisRef } : {}
+        });
+        if (res.type === "exception")
+          throw driverError("page-error", exceptionMessage(res.exceptionDetails));
+        return deserializeRemote(res.result);
+      } catch (e) {
+        throw isDriverError(e) ? e : mapBidiError(e);
+      }
+    }
+    async evaluate(expression, opts) {
+      const awaitPromise = opts?.awaitPromise ?? true;
+      if (opts?.args && opts.args.length > 0)
+        return this.callFunctionValue(expression, [...opts.args]);
+      try {
+        const res = await this.conn.send("script.evaluate", { expression, awaitPromise, target: { context: this.contextId } });
+        if (res.type === "exception")
+          throw driverError("page-error", exceptionMessage(res.exceptionDetails));
+        return deserializeRemote(res.result);
+      } catch (e) {
+        throw isDriverError(e) ? e : mapBidiError(e);
+      }
+    }
+    async callOnElement(loc, functionDeclaration, args = []) {
+      const ref = await resolveElementLocator(this.conn, this.contextId, loc);
+      return this.callFunctionValue(functionDeclaration, [...args], ref);
+    }
+    async snapshot(opts) {
+      const { snapshot } = await takeStampedSnapshot((src) => this.callFunctionValue(src, []));
+      const nodes = [];
+      for (const line of snapshot.split(`
+`)) {
+        if (!line)
+          continue;
+        const n = parseSnapshotLine(line);
+        if (n)
+          nodes.push(n);
+      }
+      return opts?.interactiveOnly ? nodes.filter((n) => INTERACTIVE_ROLES.has(n.role)) : nodes;
+    }
+    async locate(loc) {
+      if ("uid" in loc) {
+        await this.resolve(loc.uid);
+        return loc.uid;
+      }
+      const ref = await resolveElementLocator(this.conn, this.contextId, loc);
+      const stamp = await this.callFunctionValue(STAMP_ONE_SOURCE, [], ref);
+      if (typeof stamp !== "string")
+        throw driverError("page-error", "stamping the located element did not return a string");
+      return encodeUid(stamp);
+    }
+    async resolve(uid) {
+      const stamp = decodeStamp(uid);
+      const nodes = await locateNodes(this.conn, this.contextId, { type: "css", value: `[${UID_STAMP_ATTR}="${cssEscape(stamp)}"]` });
+      if (!nodes.length)
+        throw driverError("stale-uid", `uid does not resolve: ${uid}`);
+    }
+    async performActions(actions) {
+      recordDispatch("firefox", this.contextId);
+      try {
+        await this.conn.send("input.performActions", { context: this.contextId, actions });
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+    }
+    async centerOf(ref) {
+      const fn = "function(){this.scrollIntoView({block:'center',inline:'center'});const r=this.getBoundingClientRect();if(r.width===0&&r.height===0)return null;return {x:r.left+r.width/2,y:r.top+r.height/2};}";
+      const val = await this.callFunctionValue(fn, [], ref);
+      if (!val || typeof val !== "object")
+        throw driverError("page-error", "element has zero size / is not visible; cannot compute a click point");
+      return val;
+    }
+    async hover(loc) {
+      const ref = await resolveElementLocator(this.conn, this.contextId, loc);
+      const { x, y } = await this.centerOf(ref);
+      await this.performActions([{ type: "pointer", id: "cdp-mouse", actions: [{ type: "pointerMove", x, y, duration: 0 }] }]);
+      return { x, y };
+    }
+    async click(loc, opts) {
+      if (opts?.modifiers && opts.modifiers.length > 0) {
+        throw driverError("unsupported", "click: 'modifiers' is not supported by the Firefox/BiDi driver; omit 'modifiers' or use --browser chrome for a modifier click.");
+      }
+      const ref = await resolveElementLocator(this.conn, this.contextId, loc);
+      const { x, y } = await this.centerOf(ref);
+      const button = BUTTON_CODES[opts?.button ?? "left"];
+      const actions = [{ type: "pointerMove", x, y, duration: 0 }];
+      for (let i = 0;i < (opts?.clickCount ?? 1); i++)
+        actions.push({ type: "pointerDown", button }, { type: "pointerUp", button });
+      await this.performActions([{ type: "pointer", id: "cdp-mouse", actions }]);
+      return { x, y };
+    }
+    async scroll(anchor, opts) {
+      const { x, y } = await this.resolveScrollPoint(anchor);
+      const deltaX = Math.round(opts.deltaX ?? 0);
+      const deltaY = Math.round(opts.deltaY ?? 0);
+      await this.callFunctionValue(ARM_SCROLL_SETTLE_WATCH_SOURCE, []);
+      const actions = [{ type: "scroll", x: Math.round(x), y: Math.round(y), deltaX, deltaY }];
+      await this.performActions([{ type: "wheel", id: "cdp-wheel", actions }]);
+      await this.callFunctionValue(AWAIT_SCROLL_SETTLE_SOURCE, []).catch(() => {
+        return;
+      });
+      return { x, y };
+    }
+    async resolveScrollPoint(anchor) {
+      if (anchor === undefined) {
+        const v = await this.callFunctionValue("function(){return {x: window.innerWidth / 2, y: window.innerHeight / 2};}", []);
+        if (!v || typeof v !== "object")
+          throw driverError("page-error", "could not measure viewport for scroll center");
+        return v;
+      }
+      if ("x" in anchor)
+        return anchor;
+      return this.centerOf(await resolveElementLocator(this.conn, this.contextId, anchor));
+    }
+    async drag(from, to, opts) {
+      if (opts?.mode === "html5") {
+        throw driverError("unsupported", "drag: mode:'html5' is not supported by the Firefox/BiDi driver (WebDriver BiDi has no drag-interception primitive); " + "omit 'mode' for the synthetic-mouse drag, or use --browser chrome for real HTML5 drag events.");
+      }
+      const fromPt = await this.centerOf(await resolveElementLocator(this.conn, this.contextId, from));
+      const toPt = await this.resolveDragDestination(to, fromPt);
+      const steps = Math.max(1, Math.trunc(opts?.steps ?? 2));
+      const actions = [
+        { type: "pointerMove", x: fromPt.x, y: fromPt.y, duration: 0 },
+        { type: "pointerDown", button: 0 }
+      ];
+      for (const pt of interpolatePoints(fromPt, toPt, steps))
+        actions.push({ type: "pointerMove", x: pt.x, y: pt.y, duration: 50 });
+      actions.push({ type: "pointerUp", button: 0 });
+      await this.performActions([{ type: "pointer", id: "cdp-mouse", actions }]);
+      return { from: fromPt, to: toPt };
+    }
+    async resolveDragDestination(to, fromPt) {
+      if ("dx" in to)
+        return { x: fromPt.x + to.dx, y: fromPt.y + to.dy };
+      if ("x" in to)
+        return to;
+      return this.centerOf(await resolveElementLocator(this.conn, this.contextId, to));
+    }
+    async sendKeys(text) {
+      if (!text.length)
+        return;
+      const actions = [];
+      for (const ch of text)
+        actions.push({ type: "keyDown", value: ch }, { type: "keyUp", value: ch });
+      await this.performActions([{ type: "key", id: "cdp-keyboard", actions }]);
+    }
+    static SELECT_SOURCE = "function(v){var found=false;for(var i=0;i<this.options.length;i++){if(this.options[i].value===v){this.selectedIndex=i;found=true;break;}}if(!found)this.value=v;this.dispatchEvent(new Event('input',{bubbles:true}));this.dispatchEvent(new Event('change',{bubbles:true}));}";
+    static INSERT_TEXT_SOURCE = "function(v,collapseAtEnd){this.focus();var r=document.createRange();" + "r.selectNodeContents(this);if(collapseAtEnd)r.collapse(false);" + "var s=window.getSelection();s.removeAllRanges();s.addRange(r);" + "return document.execCommand('insertText', false, v);}";
+    static IS_CONTENT_EDITABLE = "function(){return this.isContentEditable===true;}";
+    async setValue(loc, value) {
+      const ref = await resolveElementLocator(this.conn, this.contextId, loc);
+      const isSelect = await this.callFunctionValue("function(){return this.tagName==='SELECT';}", [], ref);
+      if (isSelect === true) {
+        await this.callFunctionValue(BidiPageDriver.SELECT_SOURCE, [value], ref);
+        return;
+      }
+      const isContentEditable = await this.callFunctionValue(BidiPageDriver.IS_CONTENT_EDITABLE, [], ref);
+      if (isContentEditable === true) {
+        await this.callFunctionValue(BidiPageDriver.INSERT_TEXT_SOURCE, [value, false], ref);
+        return;
+      }
+      const clear = "function(){this.focus&&this.focus();if('value' in this){this.value='';this.dispatchEvent(new Event('input',{bubbles:true}));}}";
+      await this.callFunctionValue(clear, [], ref);
+      await this.sendKeys(value);
+    }
+    async typeText(loc, text) {
+      const ref = await resolveElementLocator(this.conn, this.contextId, loc);
+      const isContentEditable = await this.callFunctionValue(BidiPageDriver.IS_CONTENT_EDITABLE, [], ref);
+      if (isContentEditable === true) {
+        await this.callFunctionValue(BidiPageDriver.INSERT_TEXT_SOURCE, [text, true], ref);
+        return;
+      }
+      await this.callFunctionValue("function(){this.focus&&this.focus();}", [], ref);
+      await this.sendKeys(text);
+    }
+    async pressKey(press) {
+      const value = KEY_VALUES[press.key.toLowerCase()] ?? (press.key.length === 1 ? press.key : undefined);
+      if (value === undefined)
+        throw driverError("page-error", `unknown key '${press.key}' (use a named key like Enter/Tab/ArrowDown or a single character)`);
+      const mods = [];
+      for (const m of press.modifiers ?? []) {
+        const v = MODIFIER_VALUES[m.toLowerCase()];
+        if (v === undefined)
+          throw driverError("page-error", `unknown modifier '${m}'`);
+        mods.push(v);
+      }
+      const actions = [...mods.map((v) => ({ type: "keyDown", value: v })), { type: "keyDown", value }, { type: "keyUp", value }, ...[...mods].reverse().map((v) => ({ type: "keyUp", value: v }))];
+      await this.performActions([{ type: "key", id: "cdp-keyboard", actions }]);
+    }
+    async setFiles(loc, files) {
+      const ref = await resolveElementLocator(this.conn, this.contextId, loc);
+      try {
+        await this.conn.send("input.setFiles", { context: this.contextId, element: ref, files: [...files] });
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+    }
+    async screenshot(opts, _consumeBands) {
+      const renderSize = opts?.renderWidth !== undefined && opts?.renderHeight !== undefined ? { width: opts.renderWidth, height: opts.renderHeight } : undefined;
+      if (!renderSize)
+        return this.capture(opts);
+      const previous = await readViewportRecord(this.browser.scheme, this.contextId);
+      try {
+        await this.conn.send("browsingContext.setViewport", { context: this.contextId, viewport: { width: renderSize.width, height: renderSize.height } });
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+      let shot;
+      let captureError;
+      try {
+        shot = await this.capture(opts);
+      } catch (e) {
+        captureError = e;
+      }
+      let restoreError;
+      try {
+        if (previous) {
+          await this.conn.send("browsingContext.setViewport", {
+            context: this.contextId,
+            viewport: { width: previous.width, height: previous.height },
+            ...previous.deviceScaleFactor != null ? { devicePixelRatio: previous.deviceScaleFactor } : {}
+          });
+        } else {
+          await this.conn.send("browsingContext.setViewport", { context: this.contextId, viewport: null });
+        }
+      } catch (e) {
+        restoreError = e instanceof Error ? e.message : String(e);
+      }
+      if (!shot) {
+        if (restoreError !== undefined && captureError instanceof Error) {
+          captureError.message = `${captureError.message} ${renderRestoreFailureNote(renderSize, restoreError)}`;
+        }
+        throw captureError;
+      }
+      const result = { ...shot, renderSize, renderRestored: restoreError === undefined };
+      if (restoreError !== undefined)
+        result.renderRestoreError = restoreError;
+      return result;
+    }
+    async capture(opts) {
+      if (opts?.scale !== undefined && opts.scale !== 1) {
+        throw driverError("unsupported", `screenshot scale ${opts.scale} is not supported by this backend (WebDriver BiDi's ` + "browsingContext.captureScreenshot has no scale parameter). Call emulate with " + `deviceScaleFactor:${opts.scale} first and capture at scale 1, or use --browser chrome.`);
+      }
+      if (opts?.tile === true) {
+        throw driverError("unsupported", "screenshot tile:true is not supported by this backend: band tiling is declared only where the band " + "arithmetic has been measured against a real browser, and Firefox was not driven for it " + `(browsingContext.captureScreenshot's clip:{type:"box"} is the primitive it would ride, untested). ` + "Capture a smaller region or a single element, or use --browser chrome for a tiled capture.");
+      }
+      const format = opts?.format ?? "png";
+      const params = {
+        context: this.contextId,
+        format: { type: format === "jpeg" ? "image/jpeg" : "image/png", ...format === "jpeg" ? { quality: (opts?.quality ?? 80) / 100 } : {} }
+      };
+      if (opts?.clip)
+        params.clip = { type: "element", element: await resolveElementLocator(this.conn, this.contextId, opts.clip) };
+      else if (opts?.fullPage)
+        params.origin = "document";
+      try {
+        const { data } = await this.conn.send("browsingContext.captureScreenshot", params);
+        return { data: new Uint8Array(Buffer.from(data, "base64")), format };
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+    }
+    async emulate(opts) {
+      if (opts.clearOverrides) {
+        await this.conn.send("emulation.setUserAgentOverride", { userAgent: null, contexts: [this.contextId] }).catch(() => {
+          return;
+        });
+        await this.conn.send("browsingContext.setViewport", { context: this.contextId, viewport: null, devicePixelRatio: null }).catch(() => {
+          return;
+        });
+        await clearViewportRecord(this.browser.scheme, this.contextId);
+        return { applied: [] };
+      }
+      const applied = [];
+      try {
+        if (opts.width != null && opts.height != null) {
+          await this.conn.send("browsingContext.setViewport", { context: this.contextId, viewport: { width: opts.width, height: opts.height }, ...opts.deviceScaleFactor != null ? { devicePixelRatio: opts.deviceScaleFactor } : {} });
+          await writeViewportRecord(this.browser.scheme, this.contextId, {
+            width: opts.width,
+            height: opts.height,
+            ...opts.deviceScaleFactor != null ? { deviceScaleFactor: opts.deviceScaleFactor } : {}
+          });
+          applied.push("deviceMetrics");
+        }
+        if (opts.userAgent != null) {
+          await this.conn.send("emulation.setUserAgentOverride", { userAgent: opts.userAgent, contexts: [this.contextId] });
+          applied.push("userAgent");
+        }
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+      return { applied };
+    }
+    static EVENT_MAP = {
+      navigated: "browsingContext.navigationCommitted",
+      console: "log.entryAdded",
+      "network.request": "network.beforeRequestSent",
+      "network.response": "network.responseCompleted",
+      dialog: "browsingContext.userPromptOpened",
+      "page.closed": "browsingContext.contextDestroyed"
+    };
+    contextMatches(event, payload) {
+      if (event === "console")
+        return true;
+      return payload.context === undefined || payload.context === this.contextId;
+    }
+    on(event, handler) {
+      return this.conn.on(BidiPageDriver.EVENT_MAP[event], (params) => {
+        const p = params;
+        if (this.contextMatches(event, p))
+          handler(p);
+      });
+    }
+    async waitForEvent(event, predicate, timeoutMs) {
+      try {
+        const p = await this.conn.waitFor(BidiPageDriver.EVENT_MAP[event], (params) => {
+          const p = params;
+          return this.contextMatches(event, p) && (!predicate || predicate(p));
+        }, timeoutMs);
+        return p;
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+    }
+    async handleOneDialog(accept, promptText, timeoutMs) {
+      const opened = await this.conn.waitFor("browsingContext.userPromptOpened", (p) => p.context === this.contextId, timeoutMs).catch(() => {
+        throw driverError("timeout", `handleDialog: no dialog opened within ${timeoutMs}ms`);
+      });
+      try {
+        await this.conn.send("browsingContext.handleUserPrompt", { context: this.contextId, accept, ...promptText !== undefined ? { userText: promptText } : {} });
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+      return {
+        type: opened.type,
+        message: opened.message,
+        url: this.info.url,
+        ...opened.defaultValue !== undefined ? { defaultPrompt: opened.defaultValue } : {},
+        accept,
+        ...promptText !== undefined ? { promptText } : {},
+        handled: true
+      };
+    }
+    async handleDialog(accept, promptText, opts) {
+      if (opts?.autoMs !== undefined) {
+        const deadline = Date.now() + opts.autoMs;
+        const handled = [];
+        while (Date.now() < deadline) {
+          const remaining = deadline - Date.now();
+          if (remaining <= 0)
+            break;
+          const d = await this.handleOneDialog(accept, promptText, Math.min(250, remaining)).catch(() => {
+            return;
+          });
+          if (d)
+            handled.push(d);
+        }
+        return { handled, count: handled.length };
+      }
+      return this.handleOneDialog(accept, promptText, opts?.timeoutMs ?? 15000);
+    }
+    async getCookies() {
+      try {
+        const { cookies } = await this.conn.send("storage.getCookies", { partition: { type: "context", context: this.contextId } });
+        return (cookies ?? []).map(normalizeBidiCookie);
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+    }
+    async setCookie(params) {
+      const domain = params.domain ?? hostFromUrl(params.url, "set_cookie");
+      try {
+        await this.conn.send("storage.setCookie", {
+          cookie: {
+            name: params.name,
+            value: { type: "string", value: params.value },
+            domain,
+            ...params.path !== undefined ? { path: params.path } : {},
+            ...params.expires !== undefined ? { expiry: params.expires } : {},
+            ...params.httpOnly !== undefined ? { httpOnly: params.httpOnly } : {},
+            ...params.secure !== undefined ? { secure: params.secure } : {},
+            ...params.sameSite !== undefined ? { sameSite: params.sameSite } : {}
+          },
+          partition: { type: "context", context: this.contextId }
+        });
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+    }
+    async deleteCookies(filter) {
+      const domain = filter.domain ?? hostFromUrl(filter.url, "delete_cookies");
+      try {
+        await this.conn.send("storage.deleteCookies", {
+          filter: {
+            name: filter.name,
+            domain,
+            ...filter.path !== undefined ? { path: filter.path } : {}
+          },
+          partition: { type: "context", context: this.contextId }
+        });
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+    }
+    async startBodyCapture() {
+      let collector;
+      try {
+        const res = await this.conn.send("network.addDataCollector", { dataTypes: ["response"], maxEncodedDataSize: 1e8, contexts: [this.contextId] });
+        collector = res.collector;
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+      this.bodyCollector = collector;
+      return async () => {
+        await this.conn.send("network.removeDataCollector", { collector }).catch(() => {
+          return;
+        });
+        if (this.bodyCollector === collector)
+          this.bodyCollector = undefined;
+      };
+    }
+    async getResponseBody(requestId) {
+      if (!this.bodyCollector)
+        throw driverError("unsupported", "getResponseBody: call startBodyCapture() first (network.responseBodyPostHoc is not supported)");
+      try {
+        const { bytes } = await this.conn.send("network.getData", { dataType: "response", collector: this.bodyCollector, request: requestId });
+        return bytes.type === "base64" ? { body: bytes.value, base64Encoded: true } : { body: bytes.value, base64Encoded: false };
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+    }
+    async intercept(rules) {
+      let intercept;
+      try {
+        const res = await this.conn.send("network.addIntercept", { phases: ["beforeRequestSent"], contexts: [this.contextId] });
+        intercept = res.intercept;
+      } catch (e) {
+        throw mapBidiError(e);
+      }
+      const off = this.conn.on("network.beforeRequestSent", (params) => {
+        (async () => {
+          const req = params.request;
+          const rule = selectRule(rules, req.url, req.method);
+          if (!rule) {
+            await this.conn.send("network.continueRequest", { request: req.request }).catch(() => {
+              return;
+            });
+            return;
+          }
+          if (rule.delayMs)
+            await new Promise((r) => setTimeout(r, rule.delayMs));
+          const act = effectiveAction(rule, Math.random());
+          if (act === "fulfill") {
+            const built = buildFulfillParams(req.request, rule);
+            await this.conn.send("network.provideResponse", {
+              request: req.request,
+              statusCode: built.responseCode,
+              headers: built.responseHeaders.map((h) => ({ name: h.name, value: { type: "string", value: h.value } })),
+              body: { type: "base64", value: built.body }
+            }).catch(() => {
+              return;
+            });
+          } else if (act === "fail") {
+            await this.conn.send("network.failRequest", { request: req.request }).catch(() => {
+              return;
+            });
+          } else {
+            await this.conn.send("network.continueRequest", { request: req.request }).catch(() => {
+              return;
+            });
+          }
+        })();
+      });
+      return async () => {
+        off();
+        await this.conn.send("network.removeIntercept", { intercept }).catch(() => {
+          return;
+        });
+      };
+    }
+    async release() {
+      if (this.released)
+        return;
+      this.released = true;
+      this.conn.release();
+    }
+  };
+});
+
+// src/bidi/mux-daemon.ts
+init_session_lease();
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+var DEFAULT_IDLE_MS = 15000;
+var CLIENT_POLL_MS = 500;
+var DISPOSE_TIMEOUT_MS = 1e4;
+var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+var endpoint = process.argv[2];
+var spawnerPid = process.argv[3] ?? "?";
+function idleMs() {
+  const raw = Number(process.env.CDP_FIREFOX_MUX_IDLE_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_IDLE_MS;
+}
+function log(line) {
+  if (!endpoint)
+    return;
+  try {
+    const file = muxDaemonLogFile(endpoint);
+    mkdirSync(dirname(file), { recursive: true });
+    appendFileSync(file, `${new Date().toISOString()} pid=${process.pid} ${line}
+`);
+  } catch {}
+}
+function fail(reason) {
+  log(`EXIT(1) ${reason}`);
+  process.exit(1);
+}
+async function main() {
+  if (!endpoint)
+    fail("no endpoint argument");
+  process.env.CDP_FIREFOX_MUX = "host";
+  log(`start endpoint=${endpoint} spawner=${spawnerPid} idleMs=${idleMs()}`);
+  await Promise.resolve().then(() => init_driver2());
+  let hosted;
+  try {
+    hosted = await hostFirefoxMux(endpoint, { label: `mux-daemon(spawned by pid ${spawnerPid})` });
+  } catch (e) {
+    fail(`could not host: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  log(`advertised mux=${hosted.mux.endpoint}`);
+  let shuttingDown = false;
+  const shutdown = async (reason) => {
+    if (shuttingDown)
+      return;
+    shuttingDown = true;
+    clearInterval(timer);
+    log(`shutdown begin: ${reason}`);
+    await Promise.race([hosted.dispose().catch(() => {
+      return;
+    }), sleep3(DISPOSE_TIMEOUT_MS)]);
+    log(`EXIT(0) ${reason}`);
+    process.exit(0);
+  };
+  let idleSince = Date.now();
+  const timer = setInterval(() => {
+    if (shuttingDown)
+      return;
+    if (!hosted.conn.isOpen) {
+      shutdown("upstream Firefox connection closed");
+      return;
+    }
+    if (hosted.mux.clients() > 0) {
+      idleSince = undefined;
+      return;
+    }
+    if (idleSince === undefined)
+      idleSince = Date.now();
+    if (Date.now() - idleSince >= idleMs())
+      shutdown(`idle for ${idleMs()}ms with no clients`);
+  }, Math.max(50, Math.min(CLIENT_POLL_MS, Math.floor(idleMs() / 4))));
+  for (const sig of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+    process.on(sig, () => void shutdown(`signal ${sig}`));
+  }
+  process.on("uncaughtException", (e) => {
+    log(`uncaught: ${e instanceof Error ? e.message : String(e)}`);
+    shutdown("uncaught exception");
+  });
+}
+main().catch((e) => fail(`startup threw: ${e instanceof Error ? e.message : String(e)}`));