cdp-toolkit 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,6 +1,254 @@
-// src/tools/pages.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+// 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";
+var DEFAULT_LEASE_TTL_MS = 900000;
+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 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 };
+}
+
+class LeaseConflictError extends Error {
+  targetId;
+  holder;
+  constructor(message, targetId, holder) {
+    super(message);
+    this.targetId = targetId;
+    this.holder = holder;
+    this.name = "LeaseConflictError";
+  }
+}
+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()
+    };
+    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 };
+}
+var leaseScope = new AsyncLocalStorage;
+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)
+      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)
+      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);
+}
+var LEASE_FILE_RE = /^lease-(chrome|firefox)-(.+)\.json$/;
+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;
+}
 
 // src/client.ts
 var BASE = process.env.CDP_BASE ?? "http://127.0.0.1:9222";
@@ -155,8 +403,13 @@ async function browserWsUrl() {
   const v = await httpJson("/json/version");
   return v.webSocketDebuggerUrl;
 }
-async function resolveTarget(selector) {
+async function resolveTarget(selector, opts = {}) {
   const targets = await listTargets();
+  const hit = pickTarget(targets, selector);
+  await assertLeaseOk("chrome", hit.id, { lease: opts.lease, url: hit.url, title: hit.title });
+  return hit;
+}
+function pickTarget(targets, selector) {
   const pages = targets.filter((t) => t.type === "page");
   if (!selector || selector === "active") {
     if (!pages.length)
@@ -192,7 +445,7 @@ async function openBrowser(opts = {}) {
   return new CdpConnection(await browserWsUrl(), opts).connect();
 }
 async function openPage(selector, opts = {}) {
-  const target = await resolveTarget(selector);
+  const target = await resolveTarget(selector, { lease: opts.lease });
   const conn = await new CdpConnection(target.webSocketDebuggerUrl, opts).connect();
   return { conn, target };
 }
@@ -205,191 +458,6 @@ async function withPage(selector, fn, opts = {}) {
   }
 }
 
-// src/tools/pages.ts
-var STATE_DIR = process.env.CDP_STATE_DIR ?? "/tmp/cdp-toolkit";
-var SELECTED_FILE = `${STATE_DIR}/selected`;
-function toPageInfo(t) {
-  return { id: t.id, url: t.url, title: t.title, type: t.type };
-}
-async function listPages(args = {}) {
-  const targets = await listTargets();
-  const filtered = args.all ? targets : targets.filter((t) => t.type === "page");
-  const pages = filtered.map(toPageInfo);
-  return { pages, count: pages.length };
-}
-async function newPage(args = {}) {
-  const url = args.url ?? "about:blank";
-  const conn = await openBrowser();
-  try {
-    const { targetId } = await conn.send("Target.createTarget", { url });
-    if (!targetId)
-      throw new CdpError("Target.createTarget returned no targetId");
-    return { targetId, url };
-  } finally {
-    conn.close();
-  }
-}
-async function closePage(args) {
-  if (args.target === undefined || args.target === "") {
-    throw new CdpError("close_page requires an explicit target; refusing to guess which page to close");
-  }
-  const target = await resolveTarget(args.target);
-  const conn = await openBrowser();
-  try {
-    const res = await conn.send("Target.closeTarget", { targetId: target.id });
-    return { closed: target.id, success: res.success ?? true };
-  } finally {
-    conn.close();
-  }
-}
-async function selectPage(args) {
-  if (args.target === undefined || args.target === "") {
-    throw new CdpError("select_page requires an explicit target");
-  }
-  const target = await resolveTarget(args.target);
-  const conn = await openBrowser();
-  try {
-    await conn.send("Target.activateTarget", { targetId: target.id });
-  } finally {
-    conn.close();
-  }
-  await mkdir(dirname(SELECTED_FILE), { recursive: true });
-  await writeFile(SELECTED_FILE, target.id, "utf8");
-  return { selected: target.id };
-}
-
-// src/tools/navigation.ts
-async function navigatePage(args) {
-  const reload = args.reload === true;
-  if (!reload && (!args.url || typeof args.url !== "string")) {
-    throw new CdpError("navigate_page: 'url' is required (or pass reload:true to reload the current page)");
-  }
-  const waitUntil = args.waitUntil ?? "load";
-  return withPage(args.target, async (conn) => {
-    await conn.send("Page.enable");
-    const milestoneMethod = waitUntil === "load" ? "Page.loadEventFired" : "Page.domContentEventFired";
-    const milestone = conn.waitFor(milestoneMethod, undefined, args.timeoutMs).then(() => waitUntil).catch(() => {
-      return;
-    });
-    const stopped = conn.waitFor("Page.frameStoppedLoading", undefined, args.timeoutMs).then(() => "frameStoppedLoading").catch(() => {
-      return;
-    });
-    let resolvedUrl;
-    let frameId;
-    if (reload) {
-      await conn.send("Page.reload", { ignoreCache: args.ignoreCache === true }, args.timeoutMs ? { timeoutMs: args.timeoutMs } : {});
-      const tree = await conn.send("Page.getFrameTree").catch(() => {
-        return;
-      });
-      frameId = tree?.frameTree?.frame?.id ?? "";
-      resolvedUrl = tree?.frameTree?.frame?.url ?? args.url ?? "";
-    } else {
-      const nav = await conn.send("Page.navigate", { url: args.url }, args.timeoutMs ? { timeoutMs: args.timeoutMs } : {});
-      if (nav.errorText) {
-        throw new CdpError(`navigate_page: ${nav.errorText} (${args.url})`);
-      }
-      frameId = nav.frameId;
-      resolvedUrl = args.url;
-    }
-    const settled = await Promise.race([milestone, stopped]);
-    const waitedFor = settled ?? "navigate-only";
-    return reload ? { url: resolvedUrl, frameId, reloaded: true, waitedFor } : { url: resolvedUrl, frameId, waitedFor };
-  }, args.timeoutMs ? { timeoutMs: args.timeoutMs } : {});
-}
-var DEFAULT_WAIT_TIMEOUT_MS = 15000;
-var DEFAULT_POLL_MS = 250;
-async function waitForText(args) {
-  if (typeof args.text !== "string" || args.text.length === 0) {
-    throw new CdpError("wait_for: 'text' is required");
-  }
-  const timeoutMs = args.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
-  const pollMs = args.pollMs ?? DEFAULT_POLL_MS;
-  const start = Date.now();
-  return withPage(args.target, async (conn, _target) => {
-    await conn.send("Runtime.enable");
-    const expr = `(() => { const b = document.body; return !!b && typeof b.innerText === 'string' && b.innerText.includes(${JSON.stringify(args.text)}); })()`;
-    for (;; ) {
-      const { result } = await conn.send("Runtime.evaluate", {
-        expression: expr,
-        returnByValue: true
-      });
-      if (result?.value === true) {
-        return { found: true, waitedMs: Date.now() - start };
-      }
-      if (Date.now() - start >= timeoutMs) {
-        throw new CdpError(`wait_for: text not found within ${timeoutMs}ms: ${JSON.stringify(args.text)}`);
-      }
-      await delay(Math.min(pollMs, Math.max(0, timeoutMs - (Date.now() - start))));
-    }
-  }, { timeoutMs: Math.max(timeoutMs, DEFAULT_WAIT_TIMEOUT_MS) });
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/tools/evaluate.ts
-function exceptionMessage(details) {
-  const ex = details.exception;
-  const fromObject = ex?.description ?? (typeof ex?.value === "string" ? ex.value : ex?.value !== undefined ? JSON.stringify(ex.value) : undefined);
-  return fromObject ?? details.text ?? "evaluation threw";
-}
-function unwrap(obj) {
-  if (Object.prototype.hasOwnProperty.call(obj, "value"))
-    return obj.value;
-  if (obj.unserializableValue !== undefined)
-    return obj.unserializableValue;
-  if (obj.type === "undefined")
-    return;
-  return obj.description ?? null;
-}
-async function evaluateExpression(conn, expression, awaitPromise) {
-  const res = await conn.send("Runtime.evaluate", {
-    expression,
-    returnByValue: true,
-    awaitPromise,
-    replMode: false,
-    silent: false
-  });
-  if (res.exceptionDetails)
-    throw new CdpError(exceptionMessage(res.exceptionDetails));
-  return unwrap(res.result);
-}
-async function evaluateFunction(conn, expression, awaitPromise, args) {
-  const globalObj = await conn.send("Runtime.evaluate", {
-    expression: "globalThis",
-    returnByValue: false
-  });
-  const objectId = globalObj.result.objectId;
-  if (!objectId)
-    throw new CdpError("could not resolve global object for function call");
-  const res = await conn.send("Runtime.callFunctionOn", {
-    objectId,
-    functionDeclaration: expression,
-    arguments: args.map((value) => ({ value })),
-    returnByValue: true,
-    awaitPromise,
-    silent: false
-  });
-  if (res.exceptionDetails)
-    throw new CdpError(exceptionMessage(res.exceptionDetails));
-  return unwrap(res.result);
-}
-async function evaluateScript(args) {
-  const { expression } = args;
-  if (typeof expression !== "string" || expression.length === 0) {
-    throw new CdpError("evaluateScript: 'expression' must be a non-empty string");
-  }
-  const awaitPromise = args.awaitPromise ?? true;
-  const callArgs = args.args;
-  return withPage(args.target, async (conn) => {
-    await conn.send("Runtime.enable");
-    if (callArgs && callArgs.length > 0) {
-      return evaluateFunction(conn, expression, awaitPromise, callArgs);
-    }
-    return evaluateExpression(conn, expression, awaitPromise);
-  });
-}
-
 // src/tools/snapshot.ts
 var INTERACTIVE_ROLES = new Set([
   "button",
@@ -412,92 +480,6 @@ var INTERACTIVE_ROLES = new Set([
   "MenuItem",
   "Button"
 ]);
-function axString(v) {
-  if (!v)
-    return;
-  const raw = v.value;
-  if (raw === undefined || raw === null)
-    return;
-  const s = String(raw).trim();
-  return s.length ? s : undefined;
-}
-function propValue(node, name) {
-  const p = node.properties?.find((x) => x.name === name);
-  return axString(p?.value);
-}
-function isInteractive(role) {
-  if (!role)
-    return false;
-  return INTERACTIVE_ROLES.has(role) || INTERACTIVE_ROLES.has(role.toLowerCase());
-}
-function formatNode(node, interactiveOnly) {
-  const role = axString(node.role);
-  const name = axString(node.name);
-  const uid = node.backendDOMNodeId;
-  if (uid === undefined)
-    return;
-  if (interactiveOnly && !isInteractive(role))
-    return;
-  if (!interactiveOnly && !role && !name)
-    return;
-  const extras = [];
-  const value = axString(node.value);
-  if (value)
-    extras.push(`value=${JSON.stringify(value)}`);
-  const checked = propValue(node, "checked");
-  if (checked && checked !== "false")
-    extras.push(`checked=${checked}`);
-  const expanded = propValue(node, "expanded");
-  if (expanded)
-    extras.push(`expanded=${expanded}`);
-  const disabled = propValue(node, "disabled");
-  if (disabled === "true")
-    extras.push("disabled");
-  const url = propValue(node, "url");
-  if (url)
-    extras.push(`url=${url}`);
-  const focused = propValue(node, "focused");
-  if (focused === "true")
-    extras.push("focused");
-  const label = name ? ` ${JSON.stringify(name)}` : "";
-  const extra = extras.length ? ` [${extras.join(" ")}]` : "";
-  return `[${uid}] ${role ?? "generic"}${label}${extra}`;
-}
-async function takeSnapshot(args = {}) {
-  const interactiveOnly = args.interactiveOnly ?? false;
-  return withPage(args.target, async (conn, target) => {
-    await conn.send("Accessibility.enable");
-    const { nodes } = await conn.send("Accessibility.getFullAXTree");
-    const byId = new Map;
-    for (const n of nodes)
-      byId.set(n.nodeId, n);
-    const roots = nodes.filter((n) => !n.parentId || !byId.has(n.parentId));
-    const lines = [];
-    let nodeCount = 0;
-    const walk = (node, depth) => {
-      const line = node.ignored ? undefined : formatNode(node, interactiveOnly);
-      if (line !== undefined) {
-        const indent = interactiveOnly ? "" : "  ".repeat(depth);
-        lines.push(`${indent}${line}`);
-        nodeCount++;
-      }
-      const childDepth = line !== undefined && !interactiveOnly ? depth + 1 : depth;
-      for (const childId of node.childIds ?? []) {
-        const child = byId.get(childId);
-        if (child)
-          walk(child, childDepth);
-      }
-    };
-    for (const root of roots)
-      walk(root, 0);
-    return {
-      snapshot: lines.join(`
-`),
-      target: { id: target.id, url: target.url, title: target.title },
-      nodeCount
-    };
-  });
-}
 async function resolveUid(conn, uid) {
   const { object } = await conn.send("DOM.resolveNode", {
     backendNodeId: uid
@@ -508,149 +490,236 @@ async function resolveUid(conn, uid) {
   return { objectId: object.objectId };
 }
 
-// src/tools/input.ts
-async function resolveElement(conn, t) {
-  const hasUid = t.uid !== undefined && t.uid !== null;
-  const hasSelector = typeof t.selector === "string" && t.selector.length > 0;
-  if (hasUid === hasSelector) {
-    throw new CdpError("provide exactly one of { uid } or { selector }");
-  }
-  if (hasUid) {
-    return resolveUid(conn, t.uid);
-  }
-  const { result, exceptionDetails } = await conn.send("Runtime.evaluate", {
-    expression: `document.querySelector(${JSON.stringify(t.selector)})`,
-    returnByValue: false
-  });
-  if (exceptionDetails) {
-    throw new CdpError(`selector '${t.selector}' evaluation failed: ${exceptionDetails.text ?? "error"}`);
-  }
-  if (!result.objectId || result.subtype === "null") {
-    throw new CdpError(`selector '${t.selector}' matched no element`);
-  }
-  return { objectId: result.objectId };
+// src/tools/network_mock.ts
+function escapeRegExpChar(ch) {
+  return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
 }
-async function centerOf(conn, objectId) {
-  const { result, exceptionDetails } = await conn.send("Runtime.callFunctionOn", {
-    objectId,
-    functionDeclaration: "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};}",
-    returnByValue: true
-  });
-  if (exceptionDetails) {
-    throw new CdpError(`could not measure element: ${exceptionDetails.text ?? "error"}`);
-  }
-  if (!result.value) {
-    throw new CdpError("element has zero size / is not visible; cannot compute a click point");
+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 result.value;
-}
-async function focusElement(conn, objectId) {
-  await conn.send("Runtime.callFunctionOn", {
-    objectId,
-    functionDeclaration: "function(){this.focus&&this.focus();}",
-    returnByValue: true
-  });
-}
-async function click(args) {
-  const button = args.button ?? "left";
-  const clickCount = args.clickCount ?? 1;
-  return withPage(args.target, async (conn) => {
-    const { objectId } = await resolveElement(conn, args);
-    const { x, y } = await centerOf(conn, objectId);
-    await conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x, y });
-    await conn.send("Input.dispatchMouseEvent", { type: "mousePressed", x, y, button, clickCount });
-    await conn.send("Input.dispatchMouseEvent", { type: "mouseReleased", x, y, button, clickCount });
-    return { clicked: true, x, y };
-  });
+  return new RegExp(`^${re}$`);
 }
-async function hover(args) {
-  return withPage(args.target, async (conn) => {
-    const { objectId } = await resolveElement(conn, args);
-    const { x, y } = await centerOf(conn, objectId);
-    await conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x, y });
-    return { hovered: true, x, y };
-  });
+function urlMatches(pattern, url) {
+  return globToRegExp(pattern).test(url);
 }
-async function drag(args) {
-  if (!args.from || !args.to)
-    throw new CdpError("drag requires { from } and { to }");
-  return withPage(args.target, async (conn) => {
-    const { objectId: srcId } = await resolveElement(conn, args.from);
-    const from = await centerOf(conn, srcId);
-    const { objectId: dstId } = await resolveElement(conn, args.to);
-    const to = await centerOf(conn, dstId);
-    await conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: from.x, y: from.y });
-    await conn.send("Input.dispatchMouseEvent", {
-      type: "mousePressed",
-      x: from.x,
-      y: from.y,
-      button: "left",
-      clickCount: 1
-    });
-    await conn.send("Input.dispatchMouseEvent", {
-      type: "mouseMoved",
-      x: (from.x + to.x) / 2,
-      y: (from.y + to.y) / 2,
-      button: "left"
-    });
-    await conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: to.x, y: to.y, button: "left" });
-    await conn.send("Input.dispatchMouseEvent", {
-      type: "mouseReleased",
-      x: to.x,
-      y: to.y,
-      button: "left",
-      clickCount: 1
-    });
-    return { dragged: true, from, to };
-  });
+function selectRule(rules, url, method) {
+  return rules.find((r) => urlMatches(r.urlPattern, url) && (!r.method || r.method.toUpperCase() === method.toUpperCase()));
 }
-async function setValue(conn, objectId, value) {
-  await focusElement(conn, objectId);
-  await conn.send("Runtime.callFunctionOn", {
-    objectId,
-    functionDeclaration: "function(){if('value'in this){this.value='';this.dispatchEvent(new Event('input',{bubbles:true}));}else if(this.isContentEditable){this.textContent='';}}",
-    returnByValue: true
-  });
-  if (value.length) {
-    await conn.send("Input.insertText", { text: value });
+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")
+  };
 }
-async function fill(args) {
-  if (typeof args.value !== "string")
-    throw new CdpError("fill requires a string { value }");
-  return withPage(args.target, async (conn) => {
-    const { objectId } = await resolveElement(conn, args);
-    await setValue(conn, objectId, args.value);
-    return { filled: true, value: args.value };
-  });
-}
-async function typeText(args) {
-  if (typeof args.text !== "string")
-    throw new CdpError("type_text requires a string { text }");
-  return withPage(args.target, async (conn) => {
-    const { objectId } = await resolveElement(conn, args);
-    await focusElement(conn, objectId);
-    if (args.text.length)
-      await conn.send("Input.insertText", { text: args.text });
-    return { typed: true, text: args.text };
+function effectiveAction(rule, rnd) {
+  if (rule.failRate !== undefined && rule.failRate > 0 && rnd < rule.failRate)
+    return "fail";
+  return rule.action;
+}
+var sessions = new Map;
+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 fillForm(args) {
-  if (!Array.isArray(args.fields) || args.fields.length === 0) {
-    throw new CdpError("fill_form requires a non-empty { fields } array");
+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);
   }
-  return withPage(args.target, async (conn) => {
-    let filled = 0;
-    for (const field of args.fields) {
-      if (typeof field.value !== "string") {
-        throw new CdpError("each fill_form field requires a string value");
-      }
-      const { objectId } = await resolveElement(conn, field);
-      await setValue(conn, objectId, field.value);
-      filled++;
+  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;
     }
-    return { filled, fields: args.fields.length };
-  });
+    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 };
+}
+
+// src/driver.ts
+var UID_STAMP_ATTR = "data-cdp-uid";
+var LEGACY_NUMERIC_UID = /^[0-9]+$/;
+var 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"],
+  mock_request: ["network.intercept"],
+  list_mocks: ["network.intercept"],
+  clear_mocks: ["network.intercept"]
+};
+function isDriverError(e) {
+  return e instanceof Error && typeof e.code === "string";
+}
+
+// src/cdp/driver.ts
+function driverError(code, message, data) {
+  return Object.assign(new Error(message), { code, ...data !== undefined ? { data } : {} });
+}
+function encodeUid(backendNodeId) {
+  return `cdp:${backendNodeId}`;
+}
+function decodeUid(uid) {
+  if (LEGACY_NUMERIC_UID.test(uid))
+    return Number(uid);
+  if (!uid.startsWith("cdp:"))
+    throw driverError("foreign-uid", `uid is not owned by the cdp driver: ${uid}`);
+  const n = Number(uid.slice(4));
+  if (!Number.isSafeInteger(n) || n <= 0)
+    throw driverError("foreign-uid", `malformed cdp uid payload: ${uid}`);
+  return n;
+}
+async function centerOf(conn, objectId) {
+  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 { result, exceptionDetails } = await conn.send("Runtime.callFunctionOn", { objectId, functionDeclaration: fn, returnByValue: true });
+  if (exceptionDetails)
+    throw driverError("page-error", `could not measure element: ${exceptionDetails.text ?? "error"}`);
+  if (!result.value)
+    throw driverError("page-error", "element has zero size / is not visible; cannot compute a click point");
+  return result.value;
+}
+async function focusElement(conn, objectId) {
+  await conn.send("Runtime.callFunctionOn", { objectId, functionDeclaration: "function(){this.focus&&this.focus();}", returnByValue: true });
+}
+async function setValueOnObject(conn, objectId, value) {
+  await focusElement(conn, objectId);
+  const fn = "function(){if('value'in this){this.value='';this.dispatchEvent(new Event('input',{bubbles:true}));}else if(this.isContentEditable){this.textContent='';}}";
+  await conn.send("Runtime.callFunctionOn", { objectId, functionDeclaration: fn, returnByValue: true });
+  if (value.length)
+    await conn.send("Input.insertText", { text: value });
 }
 var NAMED_KEYS = {
   enter: { key: "Enter", code: "Enter", keyCode: 13, text: "\r" },
@@ -674,15 +743,7 @@ var NAMED_KEYS = {
   pageup: { key: "PageUp", code: "PageUp", keyCode: 33 },
   pagedown: { key: "PageDown", code: "PageDown", keyCode: 34 }
 };
-var MODIFIER_BITS = {
-  alt: 1,
-  control: 2,
-  ctrl: 2,
-  meta: 4,
-  cmd: 4,
-  command: 4,
-  shift: 8
-};
+var MODIFIER_BITS = { alt: 1, control: 2, ctrl: 2, meta: 4, cmd: 4, command: 4, shift: 8 };
 function resolveKey(key) {
   const named = NAMED_KEYS[key.toLowerCase()];
   if (named)
@@ -692,225 +753,407 @@ function resolveKey(key) {
     const isLetter = upper >= "A" && upper <= "Z";
     const isDigit = key >= "0" && key <= "9";
     const code = isLetter ? `Key${upper}` : isDigit ? `Digit${key}` : `Key${upper}`;
-    const keyCode = upper.charCodeAt(0);
-    return { key, code, keyCode, text: key };
-  }
-  throw new CdpError(`unknown key '${key}' (use a named key like Enter/Tab/ArrowDown or a single character)`);
-}
-async function pressKey(args) {
-  if (typeof args.key !== "string" || !args.key.length) {
-    throw new CdpError("press_key requires a non-empty { key }");
-  }
-  const spec = resolveKey(args.key);
-  let modBits = 0;
-  const mods = args.modifiers ?? [];
-  for (const m of mods) {
-    const bit = MODIFIER_BITS[m.toLowerCase()];
-    if (bit === undefined)
-      throw new CdpError(`unknown modifier '${m}'`);
-    modBits |= bit;
-  }
-  const suppressText = (modBits & ~MODIFIER_BITS.shift) !== 0;
-  return withPage(args.target, async (conn) => {
-    const down = {
-      type: "keyDown",
-      key: spec.key,
-      code: spec.code,
-      windowsVirtualKeyCode: spec.keyCode,
-      nativeVirtualKeyCode: spec.keyCode,
-      modifiers: modBits
-    };
-    if (spec.text && !suppressText) {
-      down.text = spec.text;
-    }
-    await conn.send("Input.dispatchKeyEvent", down);
-    await conn.send("Input.dispatchKeyEvent", {
-      type: "keyUp",
-      key: spec.key,
-      code: spec.code,
-      windowsVirtualKeyCode: spec.keyCode,
-      nativeVirtualKeyCode: spec.keyCode,
-      modifiers: modBits
-    });
-    return { pressed: spec.key, modifiers: mods };
-  });
+    return { key, code, keyCode: upper.charCodeAt(0), text: key };
+  }
+  throw driverError("page-error", `unknown key '${key}' (use a named key like Enter/Tab/ArrowDown or a single character)`);
 }
-async function uploadFile(args) {
-  const files = Array.isArray(args.files) ? args.files : [args.files];
-  if (!files.length || files.some((f) => typeof f !== "string" || !f.length)) {
-    throw new CdpError("upload_file requires { files } as a non-empty path or array of paths");
+function unwrap(obj) {
+  if (Object.prototype.hasOwnProperty.call(obj, "value"))
+    return obj.value;
+  if (obj.unserializableValue !== undefined)
+    return obj.unserializableValue;
+  return obj.type === "undefined" ? undefined : obj.description ?? null;
+}
+function exceptionMessage(details) {
+  const ex = details.exception;
+  const fromObject = ex?.description ?? (typeof ex?.value === "string" ? ex.value : ex?.value !== undefined ? JSON.stringify(ex.value) : undefined);
+  return fromObject ?? details.text ?? "evaluation threw";
+}
+var INTERACTIVE_ROLES2 = new Set([
+  "button",
+  "link",
+  "textbox",
+  "searchbox",
+  "checkbox",
+  "radio",
+  "combobox",
+  "listbox",
+  "option",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "tab",
+  "switch",
+  "slider",
+  "spinbutton",
+  "textfield"
+]);
+function axString(v) {
+  if (!v || v.value === undefined || v.value === null)
+    return;
+  const s = String(v.value).trim();
+  return s.length ? s : undefined;
+}
+function propValue(node, name) {
+  return axString(node.properties?.find((p) => p.name === name)?.value);
+}
+function isInteractive(role) {
+  return !!role && (INTERACTIVE_ROLES2.has(role) || INTERACTIVE_ROLES2.has(role.toLowerCase()));
+}
+function axExtras(node) {
+  const extras = {};
+  const value = axString(node.value);
+  if (value)
+    extras.value = value;
+  const checked = propValue(node, "checked");
+  if (checked && checked !== "false")
+    extras.checked = checked;
+  const expanded = propValue(node, "expanded");
+  if (expanded)
+    extras.expanded = expanded;
+  if (propValue(node, "disabled") === "true")
+    extras.disabled = "true";
+  const url = propValue(node, "url");
+  if (url)
+    extras.url = url;
+  if (propValue(node, "focused") === "true")
+    extras.focused = "true";
+  return extras;
+}
+async function resolveElementLocator(conn, loc) {
+  if ("uid" in loc) {
+    return resolveUid(conn, decodeUid(loc.uid)).catch(() => {
+      throw driverError("stale-uid", `uid does not resolve: ${loc.uid}`);
+    });
   }
-  return withPage(args.target, async (conn) => {
-    const { objectId } = await resolveElement(conn, args);
-    await conn.send("DOM.setFileInputFiles", { files, objectId });
-    return { uploaded: files };
+  if ("css" in loc) {
+    const { result, exceptionDetails } = await conn.send("Runtime.evaluate", { expression: `document.querySelector(${JSON.stringify(loc.css)})`, returnByValue: false });
+    if (exceptionDetails)
+      throw driverError("page-error", `css '${loc.css}' evaluation failed: ${exceptionDetails.text ?? "error"}`);
+    if (!result.objectId || result.subtype === "null")
+      throw driverError("no-such-element", `css '${loc.css}' matched no element`);
+    return { objectId: result.objectId };
+  }
+  const backendNodeId = await searchLocate(conn, "xpath" in loc ? loc.xpath : loc.text);
+  return resolveUid(conn, backendNodeId).catch(() => {
+    throw driverError("stale-uid", "text/xpath match no longer resolves");
   });
 }
-
-// src/tools/screenshot.ts
-import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
-import { join } from "node:path";
-var ARTIFACT_DIR = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
-function shortId(id) {
-  return id.slice(0, 8);
+async function searchLocate(conn, query) {
+  await conn.send("DOM.getDocument", { depth: 0 }).catch(() => {
+    return;
+  });
+  const { searchId, resultCount } = await conn.send("DOM.performSearch", { query });
+  try {
+    if (!resultCount)
+      throw driverError("no-such-element", `locator matched nothing: ${query}`);
+    const { nodeIds } = await conn.send("DOM.getSearchResults", { searchId, fromIndex: 0, toIndex: 1 });
+    const nodeId = nodeIds[0];
+    if (nodeId === undefined)
+      throw driverError("no-such-element", `locator matched nothing: ${query}`);
+    const { node } = await conn.send("DOM.describeNode", { nodeId });
+    return node.backendNodeId;
+  } finally {
+    await conn.send("DOM.discardSearchResults", { searchId }).catch(() => {
+      return;
+    });
+  }
 }
-function stamp() {
-  return new Date(Date.now()).toISOString().replace(/[:.]/g, "-");
+async function backendNodeIdOf(conn, loc) {
+  if ("uid" in loc)
+    return decodeUid(loc.uid);
+  if ("css" in loc) {
+    const { objectId } = await resolveElementLocator(conn, loc);
+    const { node } = await conn.send("DOM.describeNode", { objectId });
+    return node.backendNodeId;
+  }
+  return searchLocate(conn, "xpath" in loc ? loc.xpath : loc.text);
 }
 async function fullPageClip(conn) {
   const m = await conn.send("Page.getLayoutMetrics");
   const size = m.cssContentSize ?? m.contentSize;
   if (!size)
-    throw new CdpError("Page.getLayoutMetrics returned no content size");
-  return { x: 0, y: 0, width: Math.ceil(size.width), height: Math.ceil(size.height), scale: 1 };
-}
-async function elementClip(conn, uid, selector) {
-  let backendNodeId;
-  if (uid != null) {
-    backendNodeId = uid;
-  } else if (selector) {
-    const { root } = await conn.send("DOM.getDocument", { depth: 0 });
-    const { nodeId } = await conn.send("DOM.querySelector", {
-      nodeId: root.nodeId,
-      selector
-    });
-    if (!nodeId)
-      throw new CdpError(`selector matched no element: ${selector}`);
-    const desc = await conn.send("DOM.describeNode", { nodeId });
-    backendNodeId = desc.node.backendNodeId;
-  } else {
-    throw new CdpError("elementClip requires uid or selector");
-  }
-  try {
-    await conn.send("DOM.scrollIntoViewIfNeeded", { backendNodeId });
-  } catch {}
+    throw driverError("page-error", "Page.getLayoutMetrics returned no content size");
+  return { x: 0, y: 0, width: Math.ceil(size.width), height: Math.ceil(size.height) };
+}
+async function elementClip(conn, loc) {
+  const backendNodeId = await backendNodeIdOf(conn, loc);
+  await conn.send("DOM.scrollIntoViewIfNeeded", { backendNodeId }).catch(() => {
+    return;
+  });
   const box = await conn.send("DOM.getBoxModel", { backendNodeId });
   const q = box.model.content;
-  const q0 = q[0];
-  const q1 = q[1];
-  if (q0 == null || q1 == null)
-    throw new CdpError("DOM.getBoxModel returned an empty content quad");
   const xs = [q[0], q[2], q[4], q[6]].filter((n) => n != null);
   const ys = [q[1], q[3], q[5], q[7]].filter((n) => n != null);
-  const minX = Math.min(...xs);
-  const minY = Math.min(...ys);
-  const maxX = Math.max(...xs);
-  const maxY = Math.max(...ys);
-  const width = Math.ceil(maxX - minX);
-  const height = Math.ceil(maxY - minY);
+  if (!xs.length || !ys.length)
+    throw driverError("page-error", "DOM.getBoxModel returned an empty content quad");
+  const minX = Math.min(...xs), minY = Math.min(...ys);
+  const width = Math.ceil(Math.max(...xs) - minX), height = Math.ceil(Math.max(...ys) - minY);
   if (width <= 0 || height <= 0)
-    throw new CdpError("resolved element has zero area");
-  return { x: minX, y: minY, width, height, scale: 1 };
-}
-async function takeScreenshot(args = {}) {
-  const { target, fullPage, uid, selector, savePath, returnBase64 } = args;
-  if (uid != null && selector)
-    throw new CdpError("provide exactly one of uid or selector, not both");
-  const format = args.format ?? "png";
-  const quality = format === "jpeg" ? args.quality ?? 80 : undefined;
-  return withPage(target, async (conn, t) => {
-    await conn.send("Page.enable");
+    throw driverError("page-error", "resolved element has zero area");
+  return { x: minX, y: minY, width, height };
+}
+var CDP_CAPABILITIES = new Set([
+  "trace.performance",
+  "heap.snapshot",
+  "audit.lighthouse",
+  "emulate.cpuThrottling",
+  "emulate.mediaFeatures",
+  "emulate.deviceMetrics",
+  "emulate.networkConditions",
+  "screenshot.fullPage",
+  "screenshot.element",
+  "network.intercept",
+  "snapshot.accessibilityTree",
+  "input.insertTextAtomic",
+  "locate.text",
+  "locate.xpath"
+]);
+
+class CdpPageDriver {
+  conn;
+  browser;
+  info;
+  enabledDomains = new Set;
+  released = false;
+  constructor(conn, target, browser) {
+    this.conn = conn;
+    this.browser = browser;
+    this.info = { id: target.id, url: target.url, title: target.title, type: target.type };
+  }
+  async ensureDomain(name) {
+    if (this.enabledDomains.has(name))
+      return;
+    this.enabledDomains.add(name);
+    await this.conn.send(`${name}.enable`);
+  }
+  async ensureDomainSoft(name) {
+    if (this.enabledDomains.has(name))
+      return;
+    this.enabledDomains.add(name);
+    await this.conn.send(`${name}.enable`).catch(() => {
+      return;
+    });
+  }
+  async navigate(opts) {
+    await this.ensureDomain("Page");
+    const reload = opts.reload === true;
+    if (!reload && !opts.url)
+      throw driverError("page-error", "navigate: 'url' is required unless reload:true");
+    const waitUntil = opts.waitUntil ?? "load";
+    const milestoneMethod = waitUntil === "load" ? "Page.loadEventFired" : "Page.domContentEventFired";
+    const milestone = this.conn.waitFor(milestoneMethod, undefined, opts.timeoutMs).then(() => waitUntil).catch(() => {
+      return;
+    });
+    const stopped = this.conn.waitFor("Page.frameStoppedLoading", undefined, opts.timeoutMs).then(() => "committed").catch(() => {
+      return;
+    });
+    let url, contextId, reloaded;
+    if (reload) {
+      await this.conn.send("Page.reload", { ignoreCache: opts.ignoreCache === true }, opts.timeoutMs ? { timeoutMs: opts.timeoutMs } : {});
+      const tree = await this.conn.send("Page.getFrameTree").catch(() => {
+        return;
+      });
+      contextId = tree?.frameTree?.frame?.id ?? "";
+      url = tree?.frameTree?.frame?.url ?? opts.url ?? "";
+      reloaded = true;
+    } else {
+      const nav = await this.conn.send("Page.navigate", { url: opts.url }, opts.timeoutMs ? { timeoutMs: opts.timeoutMs } : {});
+      if (nav.errorText)
+        throw driverError("page-error", `navigate: ${nav.errorText} (${opts.url})`);
+      contextId = nav.frameId;
+      url = opts.url;
+    }
+    const settled = await Promise.race([milestone, stopped]);
+    return { url, contextId, ...reloaded ? { reloaded } : {}, waitedFor: settled ?? "timeout" };
+  }
+  async waitForText(text, timeoutMs = 15000, pollMs = 250) {
+    await this.ensureDomain("Runtime");
+    const start = Date.now();
+    const expr = `(() => { const b = document.body; return !!b && typeof b.innerText === 'string' && b.innerText.includes(${JSON.stringify(text)}); })()`;
+    for (;; ) {
+      const { result } = await this.conn.send("Runtime.evaluate", { expression: expr, returnByValue: true });
+      if (result?.value === true)
+        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 callFn(objectId, functionDeclaration, args, awaitPromise) {
+    const res = await this.conn.send("Runtime.callFunctionOn", { objectId, functionDeclaration, arguments: args.map((value) => ({ value })), returnByValue: true, awaitPromise });
+    if (res.exceptionDetails)
+      throw driverError("page-error", exceptionMessage(res.exceptionDetails));
+    return unwrap(res.result);
+  }
+  async evaluate(expression, opts) {
+    await this.ensureDomain("Runtime");
+    const awaitPromise = opts?.awaitPromise ?? true;
+    if (opts?.args && opts.args.length > 0) {
+      const globalObj = await this.conn.send("Runtime.evaluate", { expression: "globalThis", returnByValue: false });
+      const objectId = globalObj.result.objectId;
+      if (!objectId)
+        throw driverError("page-error", "could not resolve global object for function call");
+      return this.callFn(objectId, expression, opts.args, awaitPromise);
+    }
+    const res = await this.conn.send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise });
+    if (res.exceptionDetails)
+      throw driverError("page-error", exceptionMessage(res.exceptionDetails));
+    return unwrap(res.result);
+  }
+  async callOnElement(loc, functionDeclaration, args = []) {
+    const { objectId } = await resolveElementLocator(this.conn, loc);
+    return this.callFn(objectId, functionDeclaration, args, true);
+  }
+  async snapshot(opts) {
+    const interactiveOnly = opts?.interactiveOnly ?? false;
+    await this.ensureDomain("Accessibility");
+    const { nodes } = await this.conn.send("Accessibility.getFullAXTree");
+    const byId = new Map;
+    for (const n of nodes)
+      byId.set(n.nodeId, n);
+    const roots = nodes.filter((n) => !n.parentId || !byId.has(n.parentId));
+    const out = [];
+    const walk = (node, depth) => {
+      const role = axString(node.role);
+      const name = axString(node.name);
+      const backendNodeId = node.backendDOMNodeId;
+      const emitted = !node.ignored && backendNodeId !== undefined && (interactiveOnly ? isInteractive(role) : !!(role || name));
+      if (emitted) {
+        const extras = axExtras(node);
+        out.push({ uid: encodeUid(backendNodeId), role: role ?? "generic", depth, ...name ? { name } : {}, ...Object.keys(extras).length ? { extras } : {} });
+      }
+      const childDepth = emitted && !interactiveOnly ? depth + 1 : depth;
+      for (const childId of node.childIds ?? []) {
+        const child = byId.get(childId);
+        if (child)
+          walk(child, childDepth);
+      }
+    };
+    for (const root of roots)
+      walk(root, 0);
+    return out;
+  }
+  async locate(loc) {
+    return encodeUid(await backendNodeIdOf(this.conn, loc));
+  }
+  async resolve(uid) {
+    await resolveUid(this.conn, decodeUid(uid)).catch(() => {
+      throw driverError("stale-uid", `uid does not resolve: ${uid}`);
+    });
+  }
+  async hover(loc) {
+    const { objectId } = await resolveElementLocator(this.conn, loc);
+    const { x, y } = await centerOf(this.conn, objectId);
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x, y });
+    return { x, y };
+  }
+  async click(loc, opts) {
+    const button = opts?.button ?? "left";
+    const clickCount = opts?.clickCount ?? 1;
+    const { x, y } = await this.hover(loc);
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mousePressed", x, y, button, clickCount });
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mouseReleased", x, y, button, clickCount });
+    return { x, y };
+  }
+  async drag(from, to) {
+    const fromPt = await this.hover(from);
+    const { objectId: dstId } = await resolveElementLocator(this.conn, to);
+    const toPt = await centerOf(this.conn, dstId);
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mousePressed", x: fromPt.x, y: fromPt.y, button: "left", clickCount: 1 });
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: (fromPt.x + toPt.x) / 2, y: (fromPt.y + toPt.y) / 2, button: "left" });
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mouseMoved", x: toPt.x, y: toPt.y, button: "left" });
+    await this.conn.send("Input.dispatchMouseEvent", { type: "mouseReleased", x: toPt.x, y: toPt.y, button: "left", clickCount: 1 });
+    return { from: fromPt, to: toPt };
+  }
+  async setValue(loc, value) {
+    const { objectId } = await resolveElementLocator(this.conn, loc);
+    await setValueOnObject(this.conn, objectId, value);
+  }
+  async typeText(loc, text) {
+    const { objectId } = await resolveElementLocator(this.conn, loc);
+    await focusElement(this.conn, objectId);
+    if (text.length)
+      await this.conn.send("Input.insertText", { text });
+  }
+  async pressKey(press) {
+    const spec = resolveKey(press.key);
+    let modBits = 0;
+    for (const m of press.modifiers ?? []) {
+      const bit = MODIFIER_BITS[m.toLowerCase()];
+      if (bit === undefined)
+        throw driverError("page-error", `unknown modifier '${m}'`);
+      modBits |= bit;
+    }
+    const suppressText = (modBits & ~MODIFIER_BITS.shift) !== 0;
+    const down = { type: "keyDown", key: spec.key, code: spec.code, windowsVirtualKeyCode: spec.keyCode, nativeVirtualKeyCode: spec.keyCode, modifiers: modBits };
+    if (spec.text && !suppressText)
+      down.text = spec.text;
+    await this.conn.send("Input.dispatchKeyEvent", down);
+    await this.conn.send("Input.dispatchKeyEvent", { type: "keyUp", key: spec.key, code: spec.code, windowsVirtualKeyCode: spec.keyCode, nativeVirtualKeyCode: spec.keyCode, modifiers: modBits });
+  }
+  async setFiles(loc, files) {
+    const { objectId } = await resolveElementLocator(this.conn, loc);
+    await this.conn.send("DOM.setFileInputFiles", { files: [...files], objectId });
+  }
+  async screenshot(opts) {
+    await this.ensureDomain("Page");
+    const format = opts?.format ?? "png";
+    const quality = format === "jpeg" ? opts?.quality ?? 80 : undefined;
     const params = { format, captureBeyondViewport: true };
     if (quality != null)
       params.quality = quality;
-    if (uid != null || selector) {
-      params.clip = await elementClip(conn, uid, selector);
-    } else if (fullPage) {
-      params.clip = await fullPageClip(conn);
-    }
-    const { data } = await conn.send("Page.captureScreenshot", params);
-    const buf = Buffer.from(data, "base64");
-    if (buf.byteLength === 0)
-      throw new CdpError("Page.captureScreenshot returned empty data");
-    await mkdir2(ARTIFACT_DIR, { recursive: true });
-    const ext = format === "jpeg" ? "jpg" : "png";
-    const path = savePath ?? join(ARTIFACT_DIR, `screenshot-${shortId(t.id)}-${stamp()}.${ext}`);
-    await writeFile2(path, buf);
-    const result = {
-      path,
-      bytes: buf.byteLength,
-      format,
-      target: { id: t.id, url: t.url, title: t.title }
-    };
-    if (returnBase64)
-      result.base64 = data;
-    return result;
-  });
-}
-
-// src/tools/emulation.ts
-async function clearAll(conn) {
-  await conn.send("Emulation.clearDeviceMetricsOverride").catch(() => {
-    return;
-  });
-  await conn.send("Emulation.setUserAgentOverride", { userAgent: "" }).catch(() => {
-    return;
-  });
-  await conn.send("Emulation.setCPUThrottlingRate", { rate: 1 }).catch(() => {
-    return;
-  });
-  await conn.send("Emulation.setEmulatedMedia", { media: "", features: [] }).catch(() => {
-    return;
-  });
-  await conn.send("Network.enable").catch(() => {
-    return;
-  });
-  await conn.send("Network.emulateNetworkConditions", {
-    offline: false,
-    latency: 0,
-    downloadThroughput: -1,
-    uploadThroughput: -1
-  }).catch(() => {
-    return;
-  });
-}
-async function emulate(args = {}) {
-  const { target } = args;
-  return withPage(target, async (conn, t) => {
-    if (args.clearOverrides) {
-      await clearAll(conn);
-      return {
-        target: { id: t.id, url: t.url, title: t.title },
-        applied: [],
-        cleared: true
+    if (opts?.clip)
+      params.clip = { ...await elementClip(this.conn, opts.clip), scale: 1 };
+    else if (opts?.fullPage)
+      params.clip = { ...await fullPageClip(this.conn), scale: 1 };
+    const { data } = await this.conn.send("Page.captureScreenshot", params);
+    return { data: new Uint8Array(Buffer.from(data, "base64")), format };
+  }
+  async emulate(opts) {
+    if (opts.clearOverrides) {
+      const c = () => {
+        return;
       };
+      await this.conn.send("Emulation.clearDeviceMetricsOverride").catch(c);
+      await this.conn.send("Emulation.setUserAgentOverride", { userAgent: "" }).catch(c);
+      await this.conn.send("Emulation.setCPUThrottlingRate", { rate: 1 }).catch(c);
+      await this.conn.send("Emulation.setEmulatedMedia", { media: "", features: [] }).catch(c);
+      await this.ensureDomainSoft("Network");
+      await this.conn.send("Network.emulateNetworkConditions", { offline: false, latency: 0, downloadThroughput: -1, uploadThroughput: -1 }).catch(c);
+      return { applied: [] };
     }
     const applied = [];
-    if (args.width != null || args.height != null) {
-      if (args.width == null || args.height == null) {
-        throw new CdpError("emulate device metrics require both width and height");
+    if (opts.width != null || opts.height != null) {
+      if (opts.width == null || opts.height == null) {
+        throw driverError("page-error", "emulate device metrics require both width and height");
       }
-      await conn.send("Emulation.setDeviceMetricsOverride", {
-        width: args.width,
-        height: args.height,
-        deviceScaleFactor: args.deviceScaleFactor ?? 0,
-        mobile: args.mobile ?? false
+      await this.conn.send("Emulation.setDeviceMetricsOverride", {
+        width: opts.width,
+        height: opts.height,
+        deviceScaleFactor: opts.deviceScaleFactor ?? 0,
+        mobile: opts.mobile ?? false
       });
       applied.push("deviceMetrics");
     }
-    if (args.userAgent != null) {
-      await conn.send("Emulation.setUserAgentOverride", { userAgent: args.userAgent });
+    if (opts.userAgent != null) {
+      await this.conn.send("Emulation.setUserAgentOverride", { userAgent: opts.userAgent });
       applied.push("userAgent");
     }
-    if (args.cpuThrottlingRate != null) {
-      if (args.cpuThrottlingRate < 1)
-        throw new CdpError("cpuThrottlingRate must be >= 1");
-      await conn.send("Emulation.setCPUThrottlingRate", { rate: args.cpuThrottlingRate });
+    if (opts.cpuThrottlingRate != null) {
+      if (opts.cpuThrottlingRate < 1)
+        throw driverError("page-error", "cpuThrottlingRate must be >= 1");
+      await this.conn.send("Emulation.setCPUThrottlingRate", { rate: opts.cpuThrottlingRate });
       applied.push("cpuThrottlingRate");
     }
-    if (args.media != null || args.mediaFeatures != null) {
-      await conn.send("Emulation.setEmulatedMedia", {
-        media: args.media ?? "",
-        features: args.mediaFeatures ?? []
-      });
+    if (opts.media != null || opts.mediaFeatures != null) {
+      await this.conn.send("Emulation.setEmulatedMedia", { media: opts.media ?? "", features: opts.mediaFeatures ?? [] });
       applied.push("emulatedMedia");
     }
-    if (args.networkConditions != null) {
-      const n = args.networkConditions;
-      await conn.send("Network.enable").catch(() => {
-        return;
-      });
-      await conn.send("Network.emulateNetworkConditions", {
+    if (opts.networkConditions != null) {
+      const n = opts.networkConditions;
+      await this.ensureDomainSoft("Network");
+      await this.conn.send("Network.emulateNetworkConditions", {
         offline: n.offline ?? false,
         latency: n.latency ?? 0,
         downloadThroughput: n.downloadThroughput ?? -1,
@@ -919,95 +1162,542 @@ async function emulate(args = {}) {
       });
       applied.push("networkConditions");
     }
-    if (applied.length === 0) {
-      throw new CdpError("emulate: no overrides specified (pass clearOverrides:true to reset)");
+    return { applied };
+  }
+  static EVENT_MAP = {
+    navigated: { method: "Page.frameNavigated" },
+    console: { method: "Runtime.consoleAPICalled" },
+    "network.request": { method: "Network.requestWillBeSent", domain: "Network" },
+    "network.response": { method: "Network.responseReceived", domain: "Network" },
+    dialog: { method: "Page.javascriptDialogOpening" },
+    "page.closed": { method: "Inspector.detached", domain: "Inspector" }
+  };
+  on(event, handler) {
+    const spec = CdpPageDriver.EVENT_MAP[event];
+    if (spec.domain && !this.enabledDomains.has(spec.domain)) {
+      this.enabledDomains.add(spec.domain);
+      this.conn.send(`${spec.domain}.enable`);
     }
-    return { target: { id: t.id, url: t.url, title: t.title }, applied };
+    return this.conn.on(spec.method, (params) => handler(params));
+  }
+  async waitForEvent(event, predicate, timeoutMs) {
+    const spec = CdpPageDriver.EVENT_MAP[event];
+    if (spec.domain)
+      await this.ensureDomain(spec.domain);
+    return this.conn.waitFor(spec.method, predicate, timeoutMs);
+  }
+  armDialog(accept, promptText, onHandled) {
+    return this.conn.on("Page.javascriptDialogOpening", (params) => {
+      const p = params;
+      this.conn.send("Page.handleJavaScriptDialog", { accept, ...promptText !== undefined ? { promptText } : {} }).then(() => onHandled({
+        type: p.type,
+        message: p.message,
+        url: p.url,
+        ...p.defaultPrompt !== undefined ? { defaultPrompt: p.defaultPrompt } : {},
+        accept,
+        ...promptText !== undefined ? { promptText } : {},
+        handled: true
+      })).catch(() => {
+        return;
+      });
+    });
+  }
+  async handleDialog(accept, promptText, opts) {
+    await this.ensureDomain("Page");
+    if (opts?.autoMs !== undefined) {
+      const handled = [];
+      const off = this.armDialog(accept, promptText, (d) => handled.push(d));
+      await new Promise((resolve) => setTimeout(resolve, opts.autoMs));
+      off();
+      return { handled, count: handled.length };
+    }
+    const timeoutMs = opts?.timeoutMs ?? 15000;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        off();
+        reject(driverError("timeout", `handleDialog: no dialog opened within ${timeoutMs}ms`));
+      }, timeoutMs);
+      const off = this.armDialog(accept, promptText, (d) => {
+        clearTimeout(timer);
+        off();
+        resolve(d);
+      });
+    });
+  }
+  async startBodyCapture() {
+    await this.ensureDomain("Network");
+    return async () => {
+      await this.conn.send("Network.disable").catch(() => {
+        return;
+      });
+      this.enabledDomains.delete("Network");
+    };
+  }
+  async getResponseBody(requestId) {
+    return this.conn.send("Network.getResponseBody", { requestId });
+  }
+  async intercept(rules) {
+    await this.conn.send("Fetch.enable", { patterns: rules.map((r) => ({ urlPattern: r.urlPattern })) });
+    let chain = Promise.resolve();
+    const off = this.conn.on("Fetch.requestPaused", (params) => {
+      const p = params;
+      chain = chain.then(async () => {
+        const rule = selectRule(rules, p.request.url, p.request.method);
+        if (!rule) {
+          await this.conn.send("Fetch.continueRequest", { requestId: p.requestId });
+          return;
+        }
+        if (rule.delayMs)
+          await new Promise((r) => setTimeout(r, rule.delayMs));
+        const act = effectiveAction(rule, Math.random());
+        if (act === "fulfill")
+          await this.conn.send("Fetch.fulfillRequest", { ...buildFulfillParams(p.requestId, rule) });
+        else if (act === "fail")
+          await this.conn.send("Fetch.failRequest", { requestId: p.requestId, errorReason: rule.errorReason ?? "Failed" });
+        else
+          await this.conn.send("Fetch.continueRequest", { requestId: p.requestId });
+      }).catch(() => {
+        return;
+      });
+    });
+    return async () => {
+      off();
+      await this.conn.send("Fetch.disable").catch(() => {
+        return;
+      });
+    };
+  }
+  async release() {
+    if (this.released)
+      return;
+    this.released = true;
+    this.conn.close();
+  }
+}
+async function withBrowserConn(fn) {
+  const conn = await openBrowser();
+  try {
+    return await fn(conn);
+  } finally {
+    conn.close();
+  }
+}
+function noSuchTarget(e) {
+  throw driverError("no-such-target", e instanceof CdpError ? e.message : String(e));
+}
+
+class CdpBrowserDriver {
+  scheme = "cdp";
+  lifetime = "per-call";
+  capabilities = CDP_CAPABILITIES;
+  uidStability = "browser-node";
+  snapshotFidelity = "accessibility-tree";
+  async listPages(opts) {
+    const targets = await listTargets();
+    const filtered = opts?.all ? targets : targets.filter((t) => t.type === "page");
+    return filtered.map((t) => ({ id: t.id, url: t.url, title: t.title, type: t.type }));
+  }
+  async newPage(url) {
+    return withBrowserConn(async (conn) => {
+      const { targetId } = await conn.send("Target.createTarget", { url: url ?? "about:blank" });
+      if (!targetId)
+        throw driverError("page-error", "Target.createTarget returned no targetId");
+      return { id: targetId, url: url ?? "about:blank", title: "" };
+    });
+  }
+  async closePage(id) {
+    return withBrowserConn(async (conn) => {
+      const res = await conn.send("Target.closeTarget", { targetId: id });
+      return { success: res.success ?? true };
+    });
+  }
+  async activatePage(id) {
+    const target = await resolveTarget(id).catch(noSuchTarget);
+    await withBrowserConn((conn) => conn.send("Target.activateTarget", { targetId: target.id }));
+    return { id: target.id, url: target.url, title: target.title };
+  }
+  async page(selector) {
+    const { conn, target } = await openPage(selector).catch(noSuchTarget);
+    return new CdpPageDriver(conn, target, this);
+  }
+  async dispose() {}
+}
+function createCdpDriver() {
+  return new CdpBrowserDriver;
+}
+
+// src/leases-tools.ts
+class LeaseToolError extends Error {
+}
+function backendOf(driver) {
+  return driver.scheme === "bidi" ? "firefox" : "chrome";
+}
+async function claimPage(driver, args = {}) {
+  const backend = backendOf(driver);
+  const label = typeof args.label === "string" && args.label.length ? args.label : `pid-${process.pid}`;
+  const pages = await driver.listPages();
+  let targetId = args.targetId;
+  let url = args.url ?? "about:blank";
+  if (targetId === undefined || targetId === "") {
+    const page = await driver.newPage(args.url);
+    targetId = page.id;
+    url = page.url;
+  } else {
+    const existing = pages.find((p) => p.id === targetId);
+    if (!existing)
+      throw new LeaseToolError(`claim_page: no page target with id '${targetId}'`);
+    url = existing.url;
+  }
+  const liveIds = [...pages.map((p) => p.id), targetId];
+  const { record, token } = await claimLease(backend, targetId, {
+    label,
+    ttlMs: typeof args.ttlMs === "number" && args.ttlMs > 0 ? args.ttlMs : leaseTtlMs(),
+    liveIds
+  });
+  return {
+    lease: token,
+    targetId,
+    url,
+    label: record.label,
+    ttlMs: record.ttlMs,
+    expiresAt: record.lastUsedAt + record.ttlMs
+  };
+}
+async function releasePage(_driver, args) {
+  if (typeof args.lease !== "string" || !args.lease.length) {
+    throw new LeaseToolError("release_page requires the 'lease' token returned by claim_page");
+  }
+  return releaseLease(args.lease);
+}
+async function listLeasesTool(driver, _args = {}) {
+  const liveIds = (await driver.listPages()).map((p) => p.id);
+  const leases = await listLeases({ liveIds, liveBackend: backendOf(driver) });
+  return { leases, count: leases.length };
+}
+var LEASE_TOOLS = {
+  claim_page: claimPage,
+  release_page: releasePage,
+  list_leases: listLeasesTool
+};
+
+// src/shared-tools.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var ARTIFACT_DIR = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
+var STATE_DIR = process.env.CDP_STATE_DIR ?? "/tmp/cdp-toolkit";
+
+class SharedToolError extends Error {
+}
+function target3(p) {
+  return { id: p.id, url: p.url, title: p.title };
+}
+function backendOf2(driver) {
+  return driver.scheme === "bidi" ? "firefox" : "chrome";
+}
+async function withPage2(driver, target, fn) {
+  const page = await driver.page(target);
+  try {
+    return await fn(page);
+  } finally {
+    await page.release();
+  }
+}
+async function resolvePage(driver, selector) {
+  const pages = await driver.listPages();
+  const hit = await pickPage(driver, pages, selector);
+  await assertLeaseOk(backendOf2(driver), hit.id, { url: hit.url, title: hit.title });
+  return hit;
+}
+async function pickPage(driver, pages, selector) {
+  if (selector === undefined || selector === "active") {
+    if (!pages.length)
+      throw new SharedToolError("no page targets open");
+    return pages[0];
+  }
+  if (selector.startsWith("index:")) {
+    const p = pages[Number(selector.slice(6))];
+    if (!p)
+      throw new SharedToolError(`no page target at index ${selector.slice(6)} (have ${pages.length})`);
+    return p;
+  }
+  if (selector.startsWith("url:")) {
+    const needle = selector.slice(4);
+    const p = pages.find((x) => x.url.includes(needle));
+    if (!p)
+      throw new SharedToolError(`no page url containing '${needle}'`);
+    return p;
+  }
+  if (selector.startsWith("title:")) {
+    const needle = selector.slice(6);
+    const p = pages.find((x) => x.title.includes(needle));
+    if (!p)
+      throw new SharedToolError(`no page title containing '${needle}'`);
+    return p;
+  }
+  const exactPage = pages.find((x) => x.id === selector);
+  if (exactPage)
+    return exactPage;
+  const all = await driver.listPages({ all: true });
+  const exact = all.find((x) => x.id === selector);
+  if (exact)
+    return exact;
+  throw new SharedToolError(`no target with id '${selector}'`);
+}
+function locatorOf(args) {
+  const hasUid = args.uid !== undefined && args.uid !== null && args.uid !== "";
+  const hasSelector = typeof args.selector === "string" && args.selector.length > 0;
+  if (hasUid === hasSelector)
+    throw new SharedToolError("provide exactly one of { uid } or { selector }");
+  return hasUid ? { uid: args.uid } : { css: args.selector };
+}
+async function listPages(driver, args = {}) {
+  const pages = await driver.listPages({ all: args.all });
+  return { pages, count: pages.length };
+}
+async function newPage(driver, args = {}) {
+  const p = await driver.newPage(args.url);
+  if (args.claim !== true)
+    return { targetId: p.id, url: p.url };
+  const { record, token } = await claimLease(backendOf2(driver), p.id, {
+    label: typeof args.label === "string" && args.label.length ? args.label : `pid-${process.pid}`,
+    ttlMs: typeof args.ttlMs === "number" && args.ttlMs > 0 ? args.ttlMs : leaseTtlMs()
+  });
+  return { targetId: p.id, url: p.url, lease: token, label: record.label, expiresAt: record.lastUsedAt + record.ttlMs };
+}
+async function closePage(driver, args) {
+  if (args.target === undefined || args.target === "")
+    throw new SharedToolError("close_page requires an explicit target; refusing to guess which page to close");
+  const p = await resolvePage(driver, args.target);
+  const res = await driver.closePage(p.id);
+  if (!res.success)
+    return { closed: p.id, success: false, leaseReleased: false };
+  const released = await releaseLeaseFor(backendOf2(driver), p.id);
+  return { closed: p.id, success: true, ...released.released ? { leaseReleased: true } : {} };
+}
+async function writeSelectedFile(id) {
+  await mkdir2(STATE_DIR, { recursive: true });
+  await writeFile2(join2(STATE_DIR, "selected"), id, "utf8");
+}
+async function selectPage(driver, args) {
+  if (args.target === undefined || args.target === "")
+    throw new SharedToolError("select_page requires an explicit target");
+  const p = await resolvePage(driver, args.target);
+  const activated = await driver.activatePage(p.id);
+  await writeSelectedFile(activated.id);
+  return { selected: activated.id };
+}
+function toLegacyWaitedFor(w) {
+  if (w === "committed")
+    return "frameStoppedLoading";
+  if (w === "timeout")
+    return "navigate-only";
+  return w;
+}
+async function navigatePage(driver, args) {
+  const reload = args.reload === true;
+  if (!reload && (!args.url || typeof args.url !== "string")) {
+    throw new SharedToolError("navigate_page: 'url' is required (or pass reload:true to reload the current page)");
+  }
+  return withPage2(driver, args.target, async (page) => {
+    const r = await page.navigate(args);
+    return {
+      url: r.url,
+      frameId: r.contextId,
+      ...r.reloaded ? { reloaded: r.reloaded } : {},
+      waitedFor: toLegacyWaitedFor(r.waitedFor)
+    };
+  });
+}
+async function waitForText(driver, args) {
+  if (typeof args.text !== "string" || args.text.length === 0)
+    throw new SharedToolError("wait_for: 'text' is required");
+  return withPage2(driver, args.target, async (page) => {
+    const r = await page.waitForText(args.text, args.timeoutMs ?? 15000, args.pollMs ?? 250);
+    return { found: true, waitedMs: r.elapsedMs };
+  });
+}
+async function evaluateScript(driver, args) {
+  if (typeof args.expression !== "string" || args.expression.length === 0) {
+    throw new SharedToolError("evaluateScript: 'expression' must be a non-empty string");
+  }
+  return withPage2(driver, args.target, (page) => page.evaluate(args.expression, { args: args.args, awaitPromise: args.awaitPromise ?? true }));
+}
+var BARE_TOKEN_EXTRAS = new Set(["disabled", "focused"]);
+var UNQUOTED_EXTRAS = new Set(["checked", "expanded", "url"]);
+function renderSnapshotLine(n, scheme) {
+  const indent = "  ".repeat(n.depth);
+  const uidText = scheme === "cdp" && n.uid.startsWith("cdp:") ? n.uid.slice(4) : n.uid;
+  const name = n.name !== undefined ? ` ${JSON.stringify(n.name)}` : "";
+  const extrasToks = [];
+  if (n.extras) {
+    for (const [k, v] of Object.entries(n.extras)) {
+      if (BARE_TOKEN_EXTRAS.has(k))
+        extrasToks.push(k);
+      else if (UNQUOTED_EXTRAS.has(k))
+        extrasToks.push(`${k}=${v}`);
+      else
+        extrasToks.push(`${k}=${JSON.stringify(v)}`);
+    }
+  }
+  const extra = extrasToks.length ? ` [${extrasToks.join(" ")}]` : "";
+  return `${indent}[${uidText}] ${n.role}${name}${extra}`;
+}
+async function takeSnapshot(driver, args = {}) {
+  return withPage2(driver, args.target, async (page) => {
+    const nodes = await page.snapshot({ interactiveOnly: args.interactiveOnly ?? false });
+    const scheme = page.browser.scheme;
+    return { snapshot: nodes.map((n) => renderSnapshotLine(n, scheme)).join(`
+`), target: target3(page.info), nodeCount: nodes.length };
+  });
+}
+async function click(driver, args) {
+  return withPage2(driver, args.target, async (page) => {
+    const { x, y } = await page.click(locatorOf(args), { button: args.button ?? "left", clickCount: args.clickCount ?? 1 });
+    return { clicked: true, x, y };
+  });
+}
+async function hover(driver, args) {
+  return withPage2(driver, args.target, async (page) => {
+    const { x, y } = await page.hover(locatorOf(args));
+    return { hovered: true, x, y };
+  });
+}
+async function drag(driver, args) {
+  if (!args.from || !args.to)
+    throw new SharedToolError("drag requires { from } and { to }");
+  return withPage2(driver, args.target, async (page) => {
+    const { from, to } = await page.drag(locatorOf(args.from), locatorOf(args.to));
+    return { dragged: true, from, to };
+  });
+}
+async function fill(driver, args) {
+  if (typeof args.value !== "string")
+    throw new SharedToolError("fill requires a string { value }");
+  return withPage2(driver, args.target, async (page) => {
+    await page.setValue(locatorOf(args), args.value);
+    return { filled: true, value: args.value };
+  });
+}
+async function fillForm(driver, args) {
+  if (!Array.isArray(args.fields) || args.fields.length === 0)
+    throw new SharedToolError("fill_form requires a non-empty { fields } array");
+  return withPage2(driver, args.target, async (page) => {
+    let filled = 0;
+    for (const f of args.fields) {
+      if (typeof f.value !== "string")
+        throw new SharedToolError("each fill_form field requires a string value");
+      await page.setValue(locatorOf(f), f.value);
+      filled++;
+    }
+    return { filled, fields: args.fields.length };
+  });
+}
+async function typeText(driver, args) {
+  if (typeof args.text !== "string")
+    throw new SharedToolError("type_text requires a string { text }");
+  return withPage2(driver, args.target, async (page) => {
+    await page.typeText(locatorOf(args), args.text);
+    return { typed: true, text: args.text };
+  });
+}
+async function pressKey(driver, args) {
+  if (typeof args.key !== "string" || !args.key.length)
+    throw new SharedToolError("press_key requires a non-empty { key }");
+  const modifiers = args.modifiers ?? [];
+  return withPage2(driver, args.target, async (page) => {
+    await page.pressKey({ key: args.key, modifiers });
+    return { pressed: args.key, modifiers };
+  });
+}
+async function uploadFile(driver, args) {
+  const files = Array.isArray(args.files) ? args.files : [args.files];
+  if (!files.length || files.some((f) => typeof f !== "string" || !f.length)) {
+    throw new SharedToolError("upload_file requires { files } as a non-empty path or array of paths");
+  }
+  return withPage2(driver, args.target, async (page) => {
+    await page.setFiles(locatorOf(args), files);
+    return { uploaded: files };
   });
 }
-async function resizePage(args) {
-  const { target, width, height } = args;
-  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
-    throw new CdpError("resize_page requires positive numeric width and height");
-  }
-  return withPage(target, async (conn, t) => {
-    await conn.send("Emulation.setDeviceMetricsOverride", {
-      width,
-      height,
-      deviceScaleFactor: args.deviceScaleFactor ?? 0,
-      mobile: args.mobile ?? false
-    });
-    await conn.send("Runtime.enable").catch(() => {
-      return;
-    });
-    const { result } = await conn.send("Runtime.evaluate", {
-      expression: "({ w: window.innerWidth, h: window.innerHeight })",
-      returnByValue: true
-    });
-    const v = result.value;
-    return {
-      target: { id: t.id, url: t.url, title: t.title },
-      width,
-      height,
-      innerWidth: v?.w ?? width,
-      innerHeight: v?.h ?? height
+function stamp() {
+  return new Date(Date.now()).toISOString().replace(/[:.]/g, "-");
+}
+async function takeScreenshot(driver, args = {}) {
+  if (args.uid !== undefined && args.uid !== "" && args.selector)
+    throw new SharedToolError("provide exactly one of uid or selector, not both");
+  const format = args.format ?? "png";
+  return withPage2(driver, args.target, async (page) => {
+    const clip = args.uid !== undefined || args.selector ? locatorOf(args) : undefined;
+    const { data, format: outFormat } = await page.screenshot({ format, quality: args.quality, fullPage: args.fullPage, ...clip ? { clip } : {} });
+    if (data.byteLength === 0)
+      throw new SharedToolError("captureScreenshot returned empty data");
+    await mkdir2(ARTIFACT_DIR, { recursive: true });
+    const ext = outFormat === "jpeg" ? "jpg" : "png";
+    const path = args.savePath ?? join2(ARTIFACT_DIR, `screenshot-${page.info.id.slice(0, 8)}-${stamp()}.${ext}`);
+    await writeFile2(path, Buffer.from(data));
+    const result = {
+      path,
+      bytes: data.byteLength,
+      format: outFormat,
+      target: target3(page.info)
     };
+    if (args.returnBase64)
+      result.base64 = Buffer.from(data).toString("base64");
+    return result;
   });
 }
-
-// src/tools/dialogs.ts
-function armDialogHandler(conn, accept, promptText, onHandled) {
-  return conn.on("Page.javascriptDialogOpening", (params) => {
-    const ev = params;
-    (async () => {
-      try {
-        await conn.send("Page.handleJavaScriptDialog", {
-          accept,
-          ...promptText !== undefined ? { promptText } : {}
-        });
-        onHandled({
-          type: ev.type,
-          message: ev.message,
-          url: ev.url,
-          ...ev.defaultPrompt !== undefined ? { defaultPrompt: ev.defaultPrompt } : {},
-          accept,
-          ...promptText !== undefined ? { promptText } : {},
-          handled: true
-        });
-      } catch {}
-    })();
+async function emulate(driver, args = {}) {
+  return withPage2(driver, args.target, async (page) => {
+    if (args.clearOverrides) {
+      await page.emulate({ clearOverrides: true });
+      return { target: target3(page.info), applied: [], cleared: true };
+    }
+    const { applied } = await page.emulate(args);
+    if (applied.length === 0)
+      throw new SharedToolError("emulate: no overrides specified (pass clearOverrides:true to reset)");
+    return { target: target3(page.info), applied };
   });
 }
-async function handleDialog(args) {
-  const { target, accept, promptText, timeoutMs = 15000, autoMs } = args;
-  const { conn } = await openPage(target);
-  try {
-    await conn.send("Page.enable");
-    if (autoMs !== undefined) {
-      const handled = [];
-      const disarm = armDialogHandler(conn, accept, promptText, (d) => handled.push(d));
-      await new Promise((resolve) => setTimeout(resolve, autoMs));
-      disarm();
-      return { handled, count: handled.length };
-    }
-    return await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        disarm();
-        reject(new CdpError(`handle_dialog: no dialog opened within ${timeoutMs}ms`));
-      }, timeoutMs);
-      const disarm = armDialogHandler(conn, accept, promptText, (d) => {
-        clearTimeout(timer);
-        disarm();
-        resolve(d);
-      });
-    });
-  } finally {
-    conn.close();
+async function resizePage(driver, args) {
+  if (!Number.isFinite(args.width) || !Number.isFinite(args.height) || args.width <= 0 || args.height <= 0) {
+    throw new SharedToolError("resize_page requires positive numeric width and height");
   }
+  return withPage2(driver, args.target, async (page) => {
+    await page.emulate({ width: args.width, height: args.height, deviceScaleFactor: args.deviceScaleFactor, mobile: args.mobile });
+    const v = await page.evaluate("({ w: window.innerWidth, h: window.innerHeight })");
+    return { target: target3(page.info), width: args.width, height: args.height, innerWidth: v?.w ?? args.width, innerHeight: v?.h ?? args.height };
+  });
+}
+async function handleDialog(driver, args) {
+  if (args.accept === undefined)
+    throw new SharedToolError("handle_dialog requires { accept }");
+  return withPage2(driver, args.target, (page) => page.handleDialog(args.accept, args.promptText, { timeoutMs: args.timeoutMs, autoMs: args.autoMs }));
 }
+var SHARED_TOOLS = {
+  list_pages: listPages,
+  new_page: newPage,
+  close_page: closePage,
+  select_page: selectPage,
+  navigate_page: navigatePage,
+  wait_for: waitForText,
+  evaluate_script: evaluateScript,
+  take_snapshot: takeSnapshot,
+  click,
+  hover,
+  drag,
+  fill,
+  fill_form: fillForm,
+  type_text: typeText,
+  press_key: pressKey,
+  upload_file: uploadFile,
+  take_screenshot: takeScreenshot,
+  emulate,
+  resize_page: resizePage,
+  handle_dialog: handleDialog
+};
 
 // src/tools/console.ts
-import { readFile } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 
 // src/tools/recorder.ts
 import { mkdir as mkdir3, appendFile, writeFile as writeFile3, copyFile } from "node:fs/promises";
@@ -1177,7 +1867,7 @@ function lineToEntry(line, index) {
 async function readConsoleEntries(file) {
   let raw;
   try {
-    raw = await readFile(file, "utf8");
+    raw = await readFile2(file, "utf8");
   } catch {
     return [];
   }
@@ -1233,7 +1923,7 @@ async function getConsoleMessage(args = {}) {
 }
 
 // src/tools/network.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 var DEFAULT_CAPTURE_MS2 = 2500;
 function asHeaders(v) {
   if (!v || typeof v !== "object")
@@ -1300,7 +1990,7 @@ function correlate(lines) {
 async function readNetworkRequests(file) {
   let raw;
   try {
-    raw = await readFile2(file, "utf8");
+    raw = await readFile3(file, "utf8");
   } catch {
     return [];
   }
@@ -1382,8 +2072,8 @@ async function getNetworkRequest(args = {}) {
 }
 
 // src/tools/performance.ts
-import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile4, stat, unlink } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4, stat, unlink as unlink2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
 var ARTIFACT_DIR3 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 var STATE_DIR2 = process.env.CDP_STATE_DIR ?? "/tmp/cdp-toolkit";
 var DEFAULT_CATEGORIES = [
@@ -1397,11 +2087,11 @@ var liveTraces = new Map;
 function stamp2() {
   return new Date().toISOString().replace(/[:.]/g, "-");
 }
-function shortId2(id) {
+function shortId(id) {
   return id.slice(0, 8);
 }
 function stateFilePath() {
-  return join2(STATE_DIR2, "trace-state.json");
+  return join3(STATE_DIR2, "trace-state.json");
 }
 function bufferTraceData(conn, sink) {
   return conn.on("Tracing.dataCollected", (params) => {
@@ -1424,7 +2114,7 @@ async function endTrace(conn, sink, timeoutMs = 30000) {
 }
 async function writeTrace(events, targetId) {
   await mkdir4(ARTIFACT_DIR3, { recursive: true });
-  const path = join2(ARTIFACT_DIR3, `trace-${shortId2(targetId)}-${stamp2()}.json`);
+  const path = join3(ARTIFACT_DIR3, `trace-${shortId(targetId)}-${stamp2()}.json`);
   const body = JSON.stringify({ traceEvents: events, metadata: { source: "cdp-toolkit" } });
   await writeFile4(path, body, "utf8");
   const { size } = await stat(path);
@@ -1435,7 +2125,7 @@ async function performanceStartTrace(args = {}) {
   const { conn, target } = await openPage(args.target);
   if (liveTraces.has(target.id)) {
     conn.close();
-    throw new CdpError(`a trace is already in progress for target ${shortId2(target.id)}; call performanceStopTrace first`);
+    throw new CdpError(`a trace is already in progress for target ${shortId(target.id)}; call performanceStopTrace first`);
   }
   const events = [];
   bufferTraceData(conn, events);
@@ -1467,9 +2157,9 @@ async function performanceStopTrace(args = {}) {
   if (!entry) {
     let hint = "";
     try {
-      const raw = await readFile3(stateFilePath(), "utf8");
+      const raw = await readFile4(stateFilePath(), "utf8");
       const state = JSON.parse(raw);
-      hint = state.pid === process.pid ? ` (state file lists target ${shortId2(state.targetId)} but its live connection is gone)` : ` (trace was started by a DIFFERENT process pid=${state.pid}; live recordings cannot cross process boundaries)`;
+      hint = state.pid === process.pid ? ` (state file lists target ${shortId(state.targetId)} but its live connection is gone)` : ` (trace was started by a DIFFERENT process pid=${state.pid}; live recordings cannot cross process boundaries)`;
     } catch {}
     throw new CdpError(`no in-process trace to stop${hint}. Use performanceTrace for a robust single-call trace.`);
   }
@@ -1479,7 +2169,7 @@ async function performanceStopTrace(args = {}) {
   } finally {
     conn.close();
     liveTraces.delete(target.id);
-    await unlink(stateFilePath()).catch(() => {});
+    await unlink2(stateFilePath()).catch(() => {});
   }
   const written = await writeTrace(events, target.id);
   const metrics = analyzeEvents(events);
@@ -1597,7 +2287,7 @@ async function performanceAnalyzeInsight(args = {}) {
   }
   let raw;
   try {
-    raw = await readFile3(args.tracePath, "utf8");
+    raw = await readFile4(args.tracePath, "utf8");
   } catch (err) {
     throw new CdpError(`cannot read trace file '${args.tracePath}': ${err.message}`);
   }
@@ -1615,7 +2305,7 @@ async function performanceAnalyzeInsight(args = {}) {
 
 // src/tools/heap.ts
 import { mkdir as mkdir5, writeFile as writeFile5 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var ARTIFACT_DIR4 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 function stamp3(targetId) {
   const short = targetId.slice(0, 8);
@@ -1641,7 +2331,7 @@ async function takeHeapsnapshot(args = {}) {
       throw new Error("HeapProfiler.takeHeapSnapshot produced no chunks");
     }
     await mkdir5(ARTIFACT_DIR4, { recursive: true });
-    const path = args.savePath ? args.savePath.startsWith("/") ? args.savePath : join3(ARTIFACT_DIR4, args.savePath) : join3(ARTIFACT_DIR4, `take_heapsnapshot-${stamp3(target.id)}.heapsnapshot`);
+    const path = args.savePath ? args.savePath.startsWith("/") ? args.savePath : join4(ARTIFACT_DIR4, args.savePath) : join4(ARTIFACT_DIR4, `take_heapsnapshot-${stamp3(target.id)}.heapsnapshot`);
     await writeFile5(path, snapshot, "utf8");
     const bytes = Buffer.byteLength(snapshot, "utf8");
     return {
@@ -1655,7 +2345,7 @@ async function takeHeapsnapshot(args = {}) {
 
 // src/tools/lighthouse.ts
 import { spawn } from "node:child_process";
-import { mkdir as mkdir6, readFile as readFile4, stat as stat2 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile5, stat as stat2 } from "node:fs/promises";
 var ARTIFACT_DIR5 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 function cdpPort() {
   const base = process.env.CDP_BASE ?? "http://127.0.0.1:9222";
@@ -1745,7 +2435,7 @@ async function lighthouseAudit(args) {
   }
   let raw;
   try {
-    raw = await readFile4(outPath, "utf8");
+    raw = await readFile5(outPath, "utf8");
   } catch {
     raw = undefined;
   }
@@ -1753,7 +2443,7 @@ async function lighthouseAudit(args) {
     if (res.signal === "SIGKILL") {
       throw new CdpError(`lighthouse_audit timed out after ${timeoutMs}ms (no report written). stderr: ${truncate(res.stderr)}`);
     }
-    const hint = /not found|could not determine executable|npm ERR|E404|ERR_MODULE/i.test(res.stderr) ? " The Lighthouse CLI could not be fetched/installed via npx — ensure network access and that 'lighthouse' is installable." : "";
+    const hint = /not found|could not determine executable|npm ERR|E404|ERR_MODULE/i.test(res.stderr) ? " The Lighthouse CLI could not be fetched/installed via npx; ensure network access and that 'lighthouse' is installable." : "";
     throw new CdpError(`lighthouse_audit produced no report (exit code ${res.code}).${hint} stderr: ${truncate(res.stderr)}`);
   }
   let report;
@@ -1789,205 +2479,32 @@ function truncate(s, max = 600) {
   return t.length > max ? `${t.slice(0, max)}…` : t;
 }
 
-// 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;
-}
-var sessions = new Map;
-function delay3(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 delay3(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 delay3(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 };
-}
-
 // src/index.ts
+var cdpDriver = createCdpDriver();
+function onCdp(fn) {
+  return (args) => fn(cdpDriver, args);
+}
 var TOOLS = {
-  list_pages: listPages,
-  new_page: newPage,
-  close_page: closePage,
-  select_page: selectPage,
-  navigate_page: navigatePage,
-  wait_for: waitForText,
-  evaluate_script: evaluateScript,
-  take_snapshot: takeSnapshot,
-  click,
-  hover,
-  drag,
-  fill,
-  fill_form: fillForm,
-  type_text: typeText,
-  press_key: pressKey,
-  upload_file: uploadFile,
-  take_screenshot: takeScreenshot,
-  emulate,
-  resize_page: resizePage,
-  handle_dialog: handleDialog,
+  list_pages: onCdp(SHARED_TOOLS.list_pages),
+  new_page: onCdp(SHARED_TOOLS.new_page),
+  close_page: onCdp(SHARED_TOOLS.close_page),
+  select_page: onCdp(SHARED_TOOLS.select_page),
+  navigate_page: onCdp(SHARED_TOOLS.navigate_page),
+  wait_for: onCdp(SHARED_TOOLS.wait_for),
+  evaluate_script: onCdp(SHARED_TOOLS.evaluate_script),
+  take_snapshot: onCdp(SHARED_TOOLS.take_snapshot),
+  click: onCdp(SHARED_TOOLS.click),
+  hover: onCdp(SHARED_TOOLS.hover),
+  drag: onCdp(SHARED_TOOLS.drag),
+  fill: onCdp(SHARED_TOOLS.fill),
+  fill_form: onCdp(SHARED_TOOLS.fill_form),
+  type_text: onCdp(SHARED_TOOLS.type_text),
+  press_key: onCdp(SHARED_TOOLS.press_key),
+  upload_file: onCdp(SHARED_TOOLS.upload_file),
+  take_screenshot: onCdp(SHARED_TOOLS.take_screenshot),
+  emulate: onCdp(SHARED_TOOLS.emulate),
+  resize_page: onCdp(SHARED_TOOLS.resize_page),
+  handle_dialog: onCdp(SHARED_TOOLS.handle_dialog),
   list_console_messages: listConsoleMessages,
   get_console_message: getConsoleMessage,
   list_network_requests: listNetworkRequests,
@@ -2000,7 +2517,10 @@ var TOOLS = {
   lighthouse_audit: lighthouseAudit,
   mock_request: mockRequest,
   list_mocks: listMocks,
-  clear_mocks: clearMocks
+  clear_mocks: clearMocks,
+  claim_page: onCdp(LEASE_TOOLS.claim_page),
+  release_page: onCdp(LEASE_TOOLS.release_page),
+  list_leases: onCdp(LEASE_TOOLS.list_leases)
 };
 var TOOL_NAMES = Object.keys(TOOLS);
 export {