@crouton-kit/capture 1.3.3 → 1.3.5

package/bin/capture

@@ -32,50 +32,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/har-manager.ts
-function harFilePath(id) {
-  return path.join(HAR_DIR, `${id}.json`);
-}
-function createHarRecording() {
-  const id = Math.random().toString(36).slice(2, 8);
-  const harPath = harFilePath(id);
-  fs.mkdirSync(HAR_DIR, { recursive: true });
-  fs.writeFileSync(harPath, JSON.stringify({ log: { entries: [] } }, null, 2));
-  return { id, path: harPath };
-}
-function readHarRecording(id) {
-  try {
-    return JSON.parse(fs.readFileSync(harFilePath(id), "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function appendToHarRecording(id, entries) {
-  const harPath = harFilePath(id);
-  let har;
-  try {
-    har = JSON.parse(fs.readFileSync(harPath, "utf-8"));
-  } catch {
-    har = { log: { entries: [] } };
-  }
-  har.log.entries.push(...entries);
-  fs.writeFileSync(harPath, JSON.stringify(har, null, 2));
-}
-function deleteHarRecording(id) {
-  try {
-    fs.unlinkSync(harFilePath(id));
-  } catch {
-  }
-}
-var fs, path, HAR_DIR;
-var init_har_manager = __esm({
-  "src/har-manager.ts"() {
-    fs = __toESM(require("fs"));
-    path = __toESM(require("path"));
-    HAR_DIR = "/tmp/capture-har";
-  }
-});
-
 // node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
   "node_modules/.pnpm/ws@8.20.0/node_modules/ws/lib/constants.js"(exports2, module2) {
@@ -2279,7 +2235,7 @@ var require_websocket = __commonJS({
     var http = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes, createHash } = require("crypto");
+    var { randomBytes, createHash: createHash2 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2939,7 +2895,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3306,7 +3262,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = require("events");
     var http = require("http");
     var { Duplex } = require("stream");
-    var { createHash } = require("crypto");
+    var { createHash: createHash2 } = require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3607,7 +3563,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -3708,377 +3664,418 @@ var init_wrapper = __esm({
   }
 });
 
-// src/session-context.ts
-function getActiveSession() {
+// src/cdp/client.ts
+var CDPClient;
+var init_client = __esm({
+  "src/cdp/client.ts"() {
+    init_wrapper();
+    CDPClient = class {
+      ws;
+      messageId = 0;
+      pendingRequests = /* @__PURE__ */ new Map();
+      pendingTimeouts = /* @__PURE__ */ new Map();
+      eventHandlers = /* @__PURE__ */ new Map();
+      ready;
+      constructor(wsUrl, connectTimeout = 5e3) {
+        this.ws = new wrapper_default(wsUrl);
+        this.ready = new Promise((resolve4, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error(`WebSocket connection timeout (${connectTimeout}ms)`));
+          }, connectTimeout);
+          this.ws.on("open", () => {
+            clearTimeout(timeout);
+            resolve4();
+          });
+          this.ws.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(err);
+          });
+        });
+        this.ws.on("message", (data) => {
+          const msg = JSON.parse(data.toString());
+          if (msg.id !== void 0) {
+            const pending = this.pendingRequests.get(msg.id);
+            if (pending) {
+              this.pendingRequests.delete(msg.id);
+              const timer = this.pendingTimeouts.get(msg.id);
+              if (timer) {
+                clearTimeout(timer);
+                this.pendingTimeouts.delete(msg.id);
+              }
+              if (msg.error) {
+                pending.reject(new Error(msg.error.message));
+              } else {
+                pending.resolve(msg.result);
+              }
+            }
+          } else if (msg.method) {
+            const handlers = this.eventHandlers.get(msg.method);
+            handlers?.forEach((h) => h(msg.params));
+          }
+        });
+      }
+      async waitReady() {
+        await this.ready;
+      }
+      async send(method, params = {}, timeout = 6e4) {
+        await this.ready;
+        const id = ++this.messageId;
+        return new Promise((resolve4, reject) => {
+          this.pendingRequests.set(id, { resolve: resolve4, reject });
+          this.ws.send(JSON.stringify({ id, method, params }));
+          const timer = setTimeout(() => {
+            if (this.pendingRequests.has(id)) {
+              this.pendingRequests.delete(id);
+              this.pendingTimeouts.delete(id);
+              reject(new Error(`CDP request timeout (${timeout}ms): ${method}`));
+            }
+          }, timeout);
+          this.pendingTimeouts.set(id, timer);
+        });
+      }
+      on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+          this.eventHandlers.set(event, []);
+        }
+        this.eventHandlers.get(event).push(handler);
+      }
+      close() {
+        for (const timer of this.pendingTimeouts.values()) {
+          clearTimeout(timer);
+        }
+        this.pendingTimeouts.clear();
+        this.ws.close();
+      }
+    };
+  }
+});
+
+// src/cdp/detect.ts
+function getDefaultBrowserId() {
   try {
-    if (!fs2.existsSync(ACTIVE_PATH)) return null;
-    const state = JSON.parse(fs2.readFileSync(ACTIVE_PATH, "utf-8"));
-    if (!fs2.existsSync(state.dir)) {
-      clearActiveSession();
-      return null;
-    }
-    return state;
+    const output = (0, import_child_process.execSync)(
+      "defaults read com.apple.LaunchServices/com.apple.launchservices.secure LSHandlers 2>/dev/null",
+      { encoding: "utf-8" }
+    );
+    const match = output.match(
+      /LSHandlerRoleAll = "([^"]+)";\s*LSHandlerURLScheme = https;/
+    );
+    return match?.[1] ?? null;
   } catch {
     return null;
   }
 }
-function setActiveSession(state) {
-  fs2.mkdirSync(CAPTURE_ROOT, { recursive: true });
-  fs2.writeFileSync(ACTIVE_PATH, JSON.stringify(state, null, 2));
-}
-function clearActiveSession() {
+async function probeCdpPort(port) {
   try {
-    fs2.unlinkSync(ACTIVE_PATH);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 500);
+    const resp = await fetch(`http://localhost:${port}/json/version`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (resp.ok) {
+      const version = await resp.json();
+      const browser = version.Browser;
+      const userAgent = version["User-Agent"] ?? "";
+      if (!browser) return null;
+      const isElectron = userAgent.includes("Electron");
+      let app = browser;
+      if (isElectron) {
+        const appMatch = userAgent.match(
+          /(\S+?)\/[\d.]+ Chrome\/[\d.]+ Electron/
+        );
+        if (appMatch) app = appMatch[1];
+      }
+      return { browser, app, isElectron };
+    }
   } catch {
   }
+  return null;
 }
-function updateActiveSession(patch) {
-  const current = getActiveSession();
-  if (!current) return null;
-  const updated = { ...current, ...patch };
-  setActiveSession(updated);
-  return updated;
+function getLocalhostListeningPorts() {
+  try {
+    const output = (0, import_child_process.execSync)(
+      'netstat -an 2>/dev/null | grep "127.0.0.1.*LISTEN"',
+      { encoding: "utf-8" }
+    );
+    const ports = [];
+    for (const line of output.split("\n")) {
+      const match = line.match(/127\.0\.0\.1\.(\d+)/);
+      if (match) {
+        ports.push(parseInt(match[1], 10));
+      }
+    }
+    return ports;
+  } catch {
+    return [];
+  }
 }
-function sanitizeLabel(label) {
-  return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+async function detectCdpPortsAsync() {
+  const ports = getLocalhostListeningPorts();
+  const results = [];
+  const probes = ports.map(async (port) => {
+    const probe = await probeCdpPort(port);
+    if (probe) {
+      const lower = probe.browser.toLowerCase();
+      let bundleId = "unknown";
+      for (const [bid, patterns] of Object.entries(BROWSER_PATTERNS)) {
+        if (patterns.some((p) => lower.includes(p))) {
+          bundleId = bid;
+          break;
+        }
+      }
+      results.push({
+        port,
+        app: probe.app,
+        bundleId,
+        isElectron: probe.isElectron
+      });
+    }
+  });
+  await Promise.all(probes);
+  return results;
 }
-function nextStepPath(action, label) {
-  const session = getActiveSession();
-  if (!session) return null;
-  const step = session.stepCount + 1;
-  const nn = String(step).padStart(2, "0");
-  const sanitized = sanitizeLabel(label);
-  const filename = `${nn}-${action}-${sanitized}.png`;
-  const shotPath = path2.join(session.dir, "shots", filename);
-  updateActiveSession({ stepCount: step });
-  return shotPath;
+async function detectCdpPort() {
+  const endpoints = await detectCdpPortsAsync();
+  if (endpoints.length === 0) {
+    throw new Error(
+      "No browser with CDP found. Start your browser with remote debugging enabled:\n  Arc: Already enabled by default\n  Chrome: --remote-debugging-port=9222\n  Electron apps expose CDP automatically"
+    );
+  }
+  const defaultBrowser = getDefaultBrowserId();
+  if (defaultBrowser) {
+    const match = endpoints.find(
+      (p) => p.bundleId === defaultBrowser && !p.isElectron
+    );
+    if (match) return match.port;
+  }
+  const nonElectron = endpoints.find((p) => !p.isElectron);
+  return (nonElectron ?? endpoints[0]).port;
 }
-var fs2, path2, os, CAPTURE_ROOT, ACTIVE_PATH;
-var init_session_context = __esm({
-  "src/session-context.ts"() {
-    fs2 = __toESM(require("fs"));
-    path2 = __toESM(require("path"));
-    os = __toESM(require("os"));
-    CAPTURE_ROOT = path2.join(os.tmpdir(), "capture-sessions");
-    ACTIVE_PATH = path2.join(CAPTURE_ROOT, ".active");
+var import_child_process, BROWSER_PATTERNS;
+var init_detect = __esm({
+  "src/cdp/detect.ts"() {
+    import_child_process = require("child_process");
+    BROWSER_PATTERNS = {
+      "company.thebrowser.browser": ["arc"],
+      "com.google.chrome": ["chrome", "google chrome"],
+      "com.brave.browser": ["brave"],
+      "com.microsoft.edgemac": ["edge", "microsoft edge"],
+      "org.chromium.chromium": ["chromium"]
+    };
   }
 });
 
-// src/interact.ts
-async function clickByName(client, name, role) {
-  await client.send("Accessibility.enable");
-  await client.send("DOM.enable");
-  const { nodes } = await client.send("Accessibility.getFullAXTree");
-  await client.send("Accessibility.disable");
-  const nameLower = name.toLowerCase();
-  const matches = nodes.filter((n) => {
-    if (!n.backendDOMNodeId) return false;
-    if (!n.name?.value) return false;
-    if (n.name.value.toLowerCase() !== nameLower) return false;
-    if (role && n.role?.value !== role) return false;
-    return true;
-  });
-  if (matches.length === 0) {
+// src/cdp/targets.ts
+async function getBrowserClient(port) {
+  const versionResp = await fetch(`http://localhost:${port}/json/version`);
+  if (!versionResp.ok) {
     throw new Error(
-      `No element found with accessible name "${name}"${role ? ` and role "${role}"` : ""}. Run \`capture a11y --interactive\` to see available elements.`
+      `Failed to connect to CDP on port ${port}: ${versionResp.status}`
     );
   }
-  if (matches.length > 1 && !role) {
-    const INPUT_ROLES = /* @__PURE__ */ new Set(["textbox", "searchbox", "combobox", "textarea", "spinbutton"]);
-    const inputMatches = matches.filter((n) => n.role?.value && INPUT_ROLES.has(n.role.value));
-    if (inputMatches.length === 1) {
-      matches.length = 0;
-      matches.push(inputMatches[0]);
-    } else {
-      const summary = matches.slice(0, 5).map((n) => `  ${n.role?.value} "${n.name?.value}"`).join("\n");
+  const version = await versionResp.json();
+  const client = new CDPClient(version.webSocketDebuggerUrl);
+  await client.waitReady();
+  return { client, browserWsUrl: version.webSocketDebuggerUrl };
+}
+async function listTargets(port) {
+  const { client } = await getBrowserClient(port);
+  try {
+    await client.send("Target.setDiscoverTargets", { discover: true });
+    const result = await client.send("Target.getTargets");
+    return result.targetInfos.map((t) => ({
+      id: t.targetId,
+      title: t.title,
+      url: t.url,
+      type: t.type,
+      webSocketDebuggerUrl: `ws://localhost:${port}/devtools/page/${t.targetId}`
+    }));
+  } finally {
+    client.close();
+  }
+}
+async function findTab(port, urlPattern) {
+  const targets = await listTargets(port);
+  const pages = targets.filter((t) => t.type === "page");
+  if (!urlPattern) {
+    return pages[0] ?? null;
+  }
+  const pattern = urlPattern.toLowerCase();
+  return pages.find((t) => t.url.toLowerCase().includes(pattern)) ?? null;
+}
+async function findTabById(port, targetId) {
+  const targets = await listTargets(port);
+  const exact = targets.find((t) => t.id === targetId);
+  if (exact) return exact;
+  if (targetId.length >= 4) {
+    const prefix = targetId.toUpperCase();
+    const matches = targets.filter((t) => t.id.toUpperCase().startsWith(prefix));
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) {
       throw new Error(
-        `Multiple elements match "${name}" \u2014 disambiguate with --role:
-${summary}`
+        `Ambiguous target prefix "${targetId}" matches ${matches.length} tabs:
+` + matches.map((t) => `  ${t.id.slice(0, 8)}  ${t.url}`).join("\n")
       );
     }
   }
-  const match = matches[0];
-  const backendNodeId = match.backendDOMNodeId;
-  await client.send("DOM.scrollIntoViewIfNeeded", { backendNodeId });
-  const { model } = await client.send("DOM.getBoxModel", { backendNodeId });
-  const quad = model.content;
-  const x = (quad[0] + quad[2] + quad[4] + quad[6]) / 4;
-  const y = (quad[1] + quad[3] + quad[5] + quad[7]) / 4;
-  await client.send("Input.dispatchMouseEvent", {
-    type: "mousePressed",
-    x,
-    y,
-    button: "left",
-    clickCount: 1
-  });
-  await client.send("Input.dispatchMouseEvent", {
-    type: "mouseReleased",
-    x,
-    y,
-    button: "left",
-    clickCount: 1
-  });
-  return {
-    x: Math.round(x),
-    y: Math.round(y),
-    role: match.role?.value ?? "unknown",
-    name: match.name?.value ?? name
-  };
-}
-async function typeText(client, text) {
-  await client.send("Input.insertText", { text });
+  return null;
 }
-async function focusAndType(client, fieldName, text, role) {
-  const result = await clickByName(client, fieldName, role);
-  await new Promise((r) => setTimeout(r, 100));
-  await typeText(client, text);
-  return result;
+async function openTab(port, url) {
+  const { client } = await getBrowserClient(port);
+  try {
+    const result = await client.send("Target.createTarget", {
+      url,
+      background: true
+    });
+    return {
+      id: result.targetId,
+      title: "",
+      url,
+      type: "page",
+      webSocketDebuggerUrl: `ws://localhost:${port}/devtools/page/${result.targetId}`
+    };
+  } finally {
+    client.close();
+  }
 }
-var init_interact = __esm({
-  "src/interact.ts"() {
+var init_targets = __esm({
+  "src/cdp/targets.ts"() {
+    init_client();
   }
 });
 
-// src/cdp.ts
-var cdp_exports = {};
-__export(cdp_exports, {
-  CDPClient: () => CDPClient,
-  ConsoleRecorder: () => ConsoleRecorder,
-  HARRecorder: () => HARRecorder,
-  acquireTabLock: () => acquireTabLock,
-  captureScreenshot: () => captureScreenshot,
-  cdpMain: () => main,
-  detectCdpPort: () => detectCdpPort,
-  executeInBrowser: () => executeInBrowser,
-  findTab: () => findTab,
-  findTabById: () => findTabById,
-  getAccessibilityTree: () => getAccessibilityTree,
-  isTabLocked: () => isTabLocked,
-  listTargets: () => listTargets,
-  navigateAndRecord: () => navigateAndRecord,
-  navigateAndWait: () => navigateAndWait,
-  openTab: () => openTab,
-  recordTraffic: () => recordTraffic,
-  releaseTabLock: () => releaseTabLock,
-  withTabLock: () => withTabLock
-});
-function shouldRecordRequest(url) {
-  if (SKIP_EXTENSIONS.test(url)) return false;
-  if (SKIP_DOMAINS.test(url)) return false;
-  return true;
-}
-function printConsoleSummary(entries) {
-  const errors = entries.filter((e) => e.level === "error");
-  const warnings = entries.filter((e) => e.level === "warning");
-  if (errors.length > 0 || warnings.length > 0) {
-    console.error(
-      `
-Console: ${errors.length} errors, ${warnings.length} warnings`
-    );
-    for (const entry of [...errors, ...warnings]) {
-      const prefix = entry.level === "error" ? "ERR" : "WARN";
-      const src = entry.source ? ` (${entry.source})` : "";
-      const text = entry.text.length > 200 ? entry.text.slice(0, 197) + "..." : entry.text;
-      console.error(`  [${prefix}] ${text}${src}`);
+// src/session-context.ts
+function getActiveSession() {
+  try {
+    if (!fs.existsSync(ACTIVE_PATH)) return null;
+    const state = JSON.parse(fs.readFileSync(ACTIVE_PATH, "utf-8"));
+    if (!fs.existsSync(state.dir)) {
+      clearActiveSession();
+      return null;
     }
+    return state;
+  } catch {
+    return null;
   }
 }
-function writeHarAndPrintSummary(har, harOutPath) {
-  if (har.log.entries.length === 0 && !harOutPath) return void 0;
-  const harPath = harOutPath ?? `/tmp/capture-har-${Date.now()}.json`;
+function setActiveSession(state) {
+  fs.mkdirSync(CAPTURE_ROOT, { recursive: true });
+  fs.writeFileSync(ACTIVE_PATH, JSON.stringify(state, null, 2));
+}
+function clearActiveSession() {
   try {
-    fs3.writeFileSync(harPath, JSON.stringify(har, null, 2));
-  } catch (err) {
-    const stripped = {
-      log: {
-        ...har.log,
-        entries: har.log.entries.map((e) => ({
-          ...e,
-          response: { ...e.response, content: { text: "[body stripped \u2014 too large to serialize]" } }
-        }))
-      }
-    };
-    fs3.writeFileSync(harPath, JSON.stringify(stripped, null, 2));
-    console.error("  WARNING: Response bodies stripped from HAR (too large to serialize)");
-  }
-  const errors = har.log.entries.filter((e) => e.response.status >= 400);
-  console.error(
-    `
-HAR: ${har.log.entries.length} requests captured \u2192 ${harPath}`
-  );
-  if (errors.length > 0) {
-    console.error(`  ${errors.length} failed:`);
-    for (const entry of errors) {
-      const method = entry.request.method.padEnd(6);
-      const status = entry.response.status;
-      const url = entry.request.url.length > 100 ? entry.request.url.slice(0, 97) + "..." : entry.request.url;
-      console.error(`  ${method} ${status} ${url}`);
-    }
+    fs.unlinkSync(ACTIVE_PATH);
+  } catch {
   }
-  return harPath;
 }
-function parseCliArgs(argv) {
-  const command = argv[0] ?? "";
-  const positional = [];
-  const parsed = { command, positional };
-  for (let i = 1; i < argv.length; i++) {
-    const arg = argv[i];
-    const next = argv[i + 1];
-    if (arg === "--port" && next) {
-      parsed.port = parseInt(next, 10);
-      i++;
-    } else if (arg === "--out" && next) {
-      parsed.out = next;
-      i++;
-    } else if (arg === "--json") {
-      parsed.json = true;
-    } else if (arg === "--interactive") {
-      parsed.interactive = true;
-    } else if (arg === "--har-out" && next) {
-      parsed.harOut = next;
-      i++;
-    } else if (arg === "--record") {
-      parsed.record = true;
-    } else if (arg === "--duration" && next) {
-      parsed.duration = parseInt(next, 10);
-      i++;
-    } else if (arg === "--settle" && next) {
-      parsed.settle = parseInt(next, 10);
-      i++;
-    } else if (arg === "--file" && next) {
-      parsed.file = next;
-      i++;
-    } else if (arg === "--nested") {
-      parsed.nested = true;
-    } else if (arg === "--har" && next) {
-      parsed.har = next;
-      i++;
-    } else if (arg === "--new") {
-      parsed.new = true;
-    } else if (arg === "--target" && next) {
-      parsed.target = next;
-      i++;
-    } else if (arg === "--role" && next) {
-      parsed.role = next;
-      i++;
-    } else if (arg === "--into" && next) {
-      parsed.into = next;
-      i++;
-    } else if (arg === "--no-screenshot") {
-      parsed.noScreenshot = true;
-    } else if (arg === "--viewport" && next) {
-      parsed.viewport = next;
-      i++;
-    } else if (arg === "--full-page") {
-      parsed.fullPage = true;
-    } else if (arg === "--height" && next) {
-      parsed.height = parseInt(next, 10);
-      i++;
-    } else if (arg === "--filter-url" && next) {
-      parsed.filterUrl = next;
-      i++;
-    } else if (arg === "--filter-status" && next) {
-      parsed.filterStatus = next;
-      i++;
-    } else if (arg === "--filter-method" && next) {
-      parsed.filterMethod = next.toUpperCase();
-      i++;
-    } else if (arg === "--limit" && next) {
-      parsed.limit = parseInt(next, 10);
-      i++;
-    } else if (arg === "--help" || arg === "-h") {
-      parsed.help = true;
-    } else if (arg.startsWith("--")) {
-      console.error(`Unknown flag: ${arg}`);
-      process.exit(1);
-    } else {
-      positional.push(arg);
-    }
-  }
-  if (!parsed.target && process.env.CDP_TARGET) {
-    parsed.target = process.env.CDP_TARGET;
-  }
-  if (!parsed.har && process.env.CDP_HAR_ID) {
-    parsed.har = process.env.CDP_HAR_ID;
-  }
+function updateActiveSession(patch) {
+  const current = getActiveSession();
+  if (!current) return null;
+  const updated = { ...current, ...patch };
+  setActiveSession(updated);
+  return updated;
+}
+function sanitizeLabel(label) {
+  return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function nextStepPath(action, label) {
   const session = getActiveSession();
-  if (session) {
-    if (!parsed.har && session.harId) parsed.har = session.harId;
-    if (!parsed.target && session.targetId) parsed.target = session.targetId;
-  }
-  return parsed;
+  if (!session) return null;
+  const step = session.stepCount + 1;
+  const nn = String(step).padStart(2, "0");
+  const sanitized = sanitizeLabel(label);
+  const filename = `${nn}-${action}-${sanitized}.png`;
+  const shotPath = path.join(session.dir, "shots", filename);
+  updateActiveSession({ stepCount: step });
+  return shotPath;
 }
-async function connectForCommand(parsed) {
-  if (!parsed.target) {
-    throw new Error('Use --target <tabId> to target a tab. Run "capture list" to see available tabs.');
+var fs, path, os, CAPTURE_ROOT, ACTIVE_PATH;
+var init_session_context = __esm({
+  "src/session-context.ts"() {
+    fs = __toESM(require("fs"));
+    path = __toESM(require("path"));
+    os = __toESM(require("os"));
+    CAPTURE_ROOT = path.join(os.tmpdir(), "capture-sessions");
+    ACTIVE_PATH = path.join(CAPTURE_ROOT, ".active");
   }
-  let tab = null;
-  if (parsed.port) {
-    tab = await findTabById(parsed.port, parsed.target);
-  } else {
-    const endpoints = await detectCdpPortsAsync();
-    for (const ep of endpoints) {
-      try {
-        tab = await findTabById(ep.port, parsed.target);
-        if (tab) break;
-      } catch {
-      }
-    }
+});
+
+// src/cdp/screenshot.ts
+async function captureScreenshot(client, viewport, options) {
+  const MAX_DIM = 1600;
+  if (viewport) {
+    await client.send("Emulation.setDeviceMetricsOverride", {
+      width: viewport.width,
+      height: viewport.height,
+      deviceScaleFactor: 1,
+      mobile: false
+    });
+    await new Promise((r) => setTimeout(r, 150));
   }
-  if (!tab) {
-    const query = parsed.target;
-    throw new Error(
-      `No tab found for target "${query}". Run "capture list" to see available tabs.`
-    );
+  if (options?.fullPage) {
+    const layoutMetrics = await client.send("Page.getLayoutMetrics");
+    const contentWidth = layoutMetrics.cssVisualViewport?.clientWidth ?? viewport?.width ?? 1280;
+    const contentHeight = layoutMetrics.contentSize?.height ?? viewport?.height ?? 800;
+    await client.send("Emulation.setDeviceMetricsOverride", {
+      width: contentWidth,
+      height: Math.ceil(contentHeight),
+      deviceScaleFactor: 1,
+      mobile: false
+    });
+    await new Promise((r) => setTimeout(r, 150));
   }
-  if (!tab.webSocketDebuggerUrl) {
-    throw new Error("Tab has no WebSocket debugger URL");
+  let screenshotOpts = {
+    format: "png",
+    captureBeyondViewport: false
+  };
+  try {
+    const metrics = await client.send("Page.getLayoutMetrics");
+    const vw = metrics.cssVisualViewport?.clientWidth ?? 0;
+    const vh = metrics.cssVisualViewport?.clientHeight ?? 0;
+    const sx = metrics.cssVisualViewport?.pageX ?? 0;
+    const sy = metrics.cssVisualViewport?.pageY ?? 0;
+    const dprResult = await client.send("Runtime.evaluate", {
+      expression: "window.devicePixelRatio",
+      returnByValue: true
+    });
+    const dpr = dprResult.result.value ?? 1;
+    const actualMaxSide = Math.max(vw, vh) * dpr;
+    const scale = actualMaxSide > MAX_DIM ? MAX_DIM / actualMaxSide : 1 / dpr;
+    screenshotOpts = {
+      ...screenshotOpts,
+      clip: { x: sx, y: sy, width: vw, height: vh, scale }
+    };
+  } catch {
   }
-  const activeSession = getActiveSession();
-  if (activeSession && !activeSession.targetId) {
-    updateActiveSession({ targetId: tab.id });
+  const result = await client.send(
+    "Page.captureScreenshot",
+    screenshotOpts
+  );
+  if (viewport || options?.fullPage) {
+    await client.send("Emulation.clearDeviceMetricsOverride");
   }
-  const client = new CDPClient(tab.webSocketDebuggerUrl);
-  await client.waitReady();
-  return { client, tab };
+  return Buffer.from(result.data, "base64");
 }
-async function withConnection(parsed, fn, opts = {}) {
-  const { client, tab } = await connectForCommand(parsed);
-  const consoleRecorder = new ConsoleRecorder(client);
-  await consoleRecorder.start();
-  let harRecorder;
-  if (parsed.har) {
-    const harPath = harFilePath(parsed.har);
-    if (!fs3.existsSync(harPath)) {
-      console.error(
-        `ERROR: No HAR recording found for --har "${parsed.har}". Run 'har create' first.`
-      );
-      process.exit(1);
-    }
-    harRecorder = new HARRecorder(client);
-    await harRecorder.start();
-  }
-  try {
-    const result = await fn(client, tab);
-    if (harRecorder && parsed.har) {
-      const settle = opts.settle !== void 0 ? opts.settle : 3e3;
-      if (settle > 0) {
-        await new Promise((r) => setTimeout(r, settle));
-      }
-      const har = await harRecorder.finish();
-      if (har.log.entries.length > 0) {
-        appendToHarRecording(parsed.har, har.log.entries);
-        console.error(
-          `  [har:${parsed.har}] +${har.log.entries.length} entries`
-        );
-      }
-    }
-    printConsoleSummary(consoleRecorder.finish());
-    return result;
-  } finally {
-    client.close();
-  }
+async function autoScreenshot(client, action, label, noScreenshot) {
+  if (noScreenshot) return null;
+  const shotPath = nextStepPath(action, label);
+  if (!shotPath) return null;
+  await new Promise((r) => setTimeout(r, 300));
+  const png = await captureScreenshot(client);
+  fs2.writeFileSync(shotPath, png);
+  console.error(`  [screenshot] ${shotPath}`);
+  return shotPath;
 }
+var fs2;
+var init_screenshot = __esm({
+  "src/cdp/screenshot.ts"() {
+    fs2 = __toESM(require("fs"));
+    init_session_context();
+  }
+});
+
+// src/cdp/a11y.ts
 function flattenA11yTree(nodes, opts = {}, depth = 0) {
   const lines = [];
   for (const node of nodes) {
@@ -4097,263 +4094,251 @@ function flattenA11yTree(nodes, opts = {}, depth = 0) {
   }
   return lines;
 }
-function getDefaultBrowserId() {
-  try {
-    const output = (0, import_child_process.execSync)(
-      "defaults read com.apple.LaunchServices/com.apple.launchservices.secure LSHandlers 2>/dev/null",
-      { encoding: "utf-8" }
-    );
-    const match = output.match(
-      /LSHandlerRoleAll = "([^"]+)";\s*LSHandlerURLScheme = https;/
-    );
-    return match?.[1] ?? null;
-  } catch {
-    return null;
+async function getAccessibilityTree(client) {
+  await client.send("Accessibility.enable");
+  const result = await client.send("Accessibility.getFullAXTree");
+  await client.send("Accessibility.disable");
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of result.nodes) {
+    nodeMap.set(node.nodeId, node);
   }
-}
-async function probeCdpPort(port) {
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 500);
-    const resp = await fetch(`http://localhost:${port}/json/version`, {
-      signal: controller.signal
+  const SKIP_ROLES = /* @__PURE__ */ new Set(["none", "generic", "InlineTextBox"]);
+  function buildNode(node) {
+    const role = node.role?.value ?? "";
+    const childNodes = (node.childIds ?? []).flatMap((id) => {
+      const child = nodeMap.get(id);
+      return child ? buildNode(child) : [];
     });
-    clearTimeout(timeout);
-    if (resp.ok) {
-      const version = await resp.json();
-      const browser = version.Browser;
-      const userAgent = version["User-Agent"] ?? "";
-      if (!browser) return null;
-      const isElectron = userAgent.includes("Electron");
-      let app = browser;
-      if (isElectron) {
-        const appMatch = userAgent.match(
-          /(\S+?)\/[\d.]+ Chrome\/[\d.]+ Electron/
-        );
-        if (appMatch) app = appMatch[1];
-      }
-      return { browser, app, isElectron };
+    if (SKIP_ROLES.has(role)) {
+      return childNodes;
     }
-  } catch {
-  }
-  return null;
-}
-function getLocalhostListeningPorts() {
-  try {
-    const output = (0, import_child_process.execSync)(
-      'netstat -an 2>/dev/null | grep "127.0.0.1.*LISTEN"',
-      { encoding: "utf-8" }
-    );
-    const ports = [];
-    for (const line of output.split("\n")) {
-      const match = line.match(/127\.0\.0\.1\.(\d+)/);
-      if (match) {
-        ports.push(parseInt(match[1], 10));
+    return [
+      {
+        role,
+        name: node.name?.value ?? "",
+        children: childNodes
       }
-    }
-    return ports;
-  } catch {
-    return [];
+    ];
   }
+  const root = result.nodes[0];
+  return root ? buildNode(root) : [];
 }
-async function detectCdpPortsAsync() {
-  const ports = getLocalhostListeningPorts();
-  const results = [];
-  const probes = ports.map(async (port) => {
-    const probe = await probeCdpPort(port);
-    if (probe) {
-      const lower = probe.browser.toLowerCase();
-      let bundleId = "unknown";
-      for (const [bid, patterns] of Object.entries(BROWSER_PATTERNS)) {
-        if (patterns.some((p) => lower.includes(p))) {
-          bundleId = bid;
-          break;
-        }
-      }
-      results.push({
-        port,
-        app: probe.app,
-        bundleId,
-        isElectron: probe.isElectron
-      });
-    }
-  });
-  await Promise.all(probes);
-  return results;
-}
-async function detectCdpPort() {
-  const endpoints = await detectCdpPortsAsync();
-  if (endpoints.length === 0) {
-    throw new Error(
-      "No browser with CDP found. Start your browser with remote debugging enabled:\n  Arc: Already enabled by default\n  Chrome: --remote-debugging-port=9222\n  Electron apps expose CDP automatically"
-    );
+var INTERACTIVE_ROLES;
+var init_a11y = __esm({
+  "src/cdp/a11y.ts"() {
+    INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+      "button",
+      "link",
+      "textbox",
+      "searchbox",
+      "combobox",
+      "checkbox",
+      "radio",
+      "menuitem",
+      "tab",
+      "switch",
+      "slider",
+      "spinbutton",
+      "option",
+      "menuitemcheckbox",
+      "menuitemradio"
+    ]);
   }
-  const defaultBrowser = getDefaultBrowserId();
-  if (defaultBrowser) {
-    const match = endpoints.find(
-      (p) => p.bundleId === defaultBrowser && !p.isElectron
+});
+
+// src/cdp/console-recorder.ts
+function printConsoleSummary(entries) {
+  const errors = entries.filter((e) => e.level === "error");
+  const warnings = entries.filter((e) => e.level === "warning");
+  if (errors.length > 0 || warnings.length > 0) {
+    console.error(
+      `
+Console: ${errors.length} errors, ${warnings.length} warnings`
     );
-    if (match) return match.port;
+    for (const entry of [...errors, ...warnings]) {
+      const prefix = entry.level === "error" ? "ERR" : "WARN";
+      const src = entry.source ? ` (${entry.source})` : "";
+      const text = entry.text.length > 200 ? entry.text.slice(0, 197) + "..." : entry.text;
+      console.error(`  [${prefix}] ${text}${src}`);
+    }
   }
-  const nonElectron = endpoints.find((p) => !p.isElectron);
-  return (nonElectron ?? endpoints[0]).port;
 }
-async function getBrowserClient(port) {
-  const versionResp = await fetch(`http://localhost:${port}/json/version`);
-  if (!versionResp.ok) {
-    throw new Error(
-      `Failed to connect to CDP on port ${port}: ${versionResp.status}`
-    );
+var ConsoleRecorder;
+var init_console_recorder = __esm({
+  "src/cdp/console-recorder.ts"() {
+    ConsoleRecorder = class {
+      constructor(client) {
+        this.client = client;
+      }
+      entries = [];
+      async start() {
+        await this.client.send("Runtime.enable");
+        this.client.on("Runtime.consoleAPICalled", (params) => {
+          const p = params;
+          const text = p.args.map(
+            (a) => a.value !== void 0 ? String(a.value) : a.description ?? ""
+          ).join(" ");
+          this.entries.push({
+            level: p.type,
+            text,
+            timestamp: p.timestamp
+          });
+        });
+        this.client.on("Runtime.exceptionThrown", (params) => {
+          const p = params;
+          this.entries.push({
+            level: "error",
+            text: p.exceptionDetails.exception?.description ?? p.exceptionDetails.text ?? "Unknown exception",
+            timestamp: p.timestamp,
+            source: p.exceptionDetails.url ? `${p.exceptionDetails.url}:${p.exceptionDetails.lineNumber}` : void 0
+          });
+        });
+      }
+      finish() {
+        return [...this.entries];
+      }
+    };
   }
-  const version = await versionResp.json();
-  const client = new CDPClient(version.webSocketDebuggerUrl);
-  await client.waitReady();
-  return { client, browserWsUrl: version.webSocketDebuggerUrl };
+});
+
+// src/cdp/har-recorder.ts
+function shouldRecordRequest(url) {
+  if (SKIP_EXTENSIONS.test(url)) return false;
+  if (SKIP_DOMAINS.test(url)) return false;
+  return true;
 }
-async function listTargets(port) {
-  const { client } = await getBrowserClient(port);
+var SKIP_EXTENSIONS, SKIP_DOMAINS, MAX_BODY_SIZE, HARRecorder;
+var init_har_recorder = __esm({
+  "src/cdp/har-recorder.ts"() {
+    SKIP_EXTENSIONS = /\.(png|jpg|jpeg|gif|webp|svg|ico|woff2?|ttf|eot|css|mp4|webm|mp3)(\?|$)/i;
+    SKIP_DOMAINS = /(google-analytics|googletagmanager|doubleclick|facebook\.com\/tr|px\.ads|analytics|tracking|beacon|telemetry)/i;
+    MAX_BODY_SIZE = 256 * 1024;
+    HARRecorder = class {
+      constructor(client) {
+        this.client = client;
+      }
+      requests = /* @__PURE__ */ new Map();
+      responses = /* @__PURE__ */ new Map();
+      get responseCount() {
+        return this.responses.size;
+      }
+      async start() {
+        await this.client.send("Network.enable");
+        this.client.on("Network.requestWillBeSent", (params) => {
+          const p = params;
+          if (!shouldRecordRequest(p.request.url)) return;
+          this.requests.set(p.requestId, {
+            requestId: p.requestId,
+            url: p.request.url,
+            method: p.request.method,
+            headers: p.request.headers,
+            postData: p.request.postData,
+            timestamp: p.timestamp
+          });
+        });
+        this.client.on("Network.responseReceived", (params) => {
+          const p = params;
+          if (!this.requests.has(p.requestId)) return;
+          this.responses.set(p.requestId, {
+            requestId: p.requestId,
+            url: p.response.url,
+            status: p.response.status,
+            headers: p.response.headers,
+            timestamp: p.timestamp
+          });
+        });
+      }
+      buildHar() {
+        return {
+          log: {
+            entries: Array.from(this.responses.values()).map((resp) => {
+              const req = this.requests.get(resp.requestId);
+              return {
+                startedDateTime: new Date(resp.timestamp * 1e3).toISOString(),
+                request: {
+                  method: req?.method ?? "GET",
+                  url: resp.url,
+                  headers: Object.entries(req?.headers ?? {}).map(
+                    ([name, value]) => ({ name, value })
+                  ),
+                  postData: req?.postData ? { text: req.postData } : void 0
+                },
+                response: {
+                  status: resp.status,
+                  headers: Object.entries(resp.headers).map(([name, value]) => ({
+                    name,
+                    value
+                  })),
+                  content: { text: resp.body }
+                }
+              };
+            })
+          }
+        };
+      }
+      async finish() {
+        await Promise.allSettled(
+          Array.from(this.responses.entries()).map(async ([reqId, resp]) => {
+            const bodyResult = await this.client.send("Network.getResponseBody", {
+              requestId: reqId
+            }, 5e3);
+            const decoded = bodyResult.base64Encoded ? Buffer.from(bodyResult.body, "base64").toString() : bodyResult.body;
+            resp.body = decoded.length > MAX_BODY_SIZE ? decoded.slice(0, MAX_BODY_SIZE) + `
+[truncated: ${decoded.length} bytes]` : decoded;
+          })
+        );
+        return this.buildHar();
+      }
+      finishPartial() {
+        return this.buildHar();
+      }
+    };
+  }
+});
+
+// src/cdp/har-output.ts
+function writeHarAndPrintSummary(har, harOutPath) {
+  if (har.log.entries.length === 0 && !harOutPath) return void 0;
+  const harPath = harOutPath ?? `/tmp/capture-har-${Date.now()}.json`;
   try {
-    await client.send("Target.setDiscoverTargets", { discover: true });
-    const result = await client.send("Target.getTargets");
-    return result.targetInfos.map((t) => ({
-      id: t.targetId,
-      title: t.title,
-      url: t.url,
-      type: t.type,
-      webSocketDebuggerUrl: `ws://localhost:${port}/devtools/page/${t.targetId}`
-    }));
-  } finally {
-    client.close();
+    fs3.writeFileSync(harPath, JSON.stringify(har, null, 2));
+  } catch (err) {
+    const stripped = {
+      log: {
+        ...har.log,
+        entries: har.log.entries.map((e) => ({
+          ...e,
+          response: { ...e.response, content: { text: "[body stripped \u2014 too large to serialize]" } }
+        }))
+      }
+    };
+    fs3.writeFileSync(harPath, JSON.stringify(stripped, null, 2));
+    console.error("  WARNING: Response bodies stripped from HAR (too large to serialize)");
   }
-}
-async function findTab(port, urlPattern) {
-  const targets = await listTargets(port);
-  const pages = targets.filter((t) => t.type === "page");
-  if (!urlPattern) {
-    return pages[0] ?? null;
+  const errors = har.log.entries.filter((e) => e.response.status >= 400);
+  console.error(
+    `
+HAR: ${har.log.entries.length} requests captured \u2192 ${harPath}`
+  );
+  if (errors.length > 0) {
+    console.error(`  ${errors.length} failed:`);
+    for (const entry of errors) {
+      const method = entry.request.method.padEnd(6);
+      const status = entry.response.status;
+      const url = entry.request.url.length > 100 ? entry.request.url.slice(0, 97) + "..." : entry.request.url;
+      console.error(`  ${method} ${status} ${url}`);
+    }
   }
-  const pattern = urlPattern.toLowerCase();
-  return pages.find((t) => t.url.toLowerCase().includes(pattern)) ?? null;
+  return harPath;
 }
-async function findTabById(port, targetId) {
-  const targets = await listTargets(port);
-  const exact = targets.find((t) => t.id === targetId);
-  if (exact) return exact;
-  if (targetId.length >= 4) {
-    const prefix = targetId.toUpperCase();
-    const matches = targets.filter((t) => t.id.toUpperCase().startsWith(prefix));
-    if (matches.length === 1) return matches[0];
-    if (matches.length > 1) {
-      throw new Error(
-        `Ambiguous target prefix "${targetId}" matches ${matches.length} tabs:
-` + matches.map((t) => `  ${t.id.slice(0, 8)}  ${t.url}`).join("\n")
-      );
-    }
-  }
-  return null;
-}
-async function openTab(port, url) {
-  const { client } = await getBrowserClient(port);
-  try {
-    const result = await client.send("Target.createTarget", {
-      url,
-      background: true
-    });
-    return {
-      id: result.targetId,
-      title: "",
-      url,
-      type: "page",
-      webSocketDebuggerUrl: `ws://localhost:${port}/devtools/page/${result.targetId}`
-    };
-  } finally {
-    client.close();
-  }
-}
-async function captureScreenshot(client, viewport, options) {
-  const MAX_DIM = 1600;
-  if (viewport) {
-    await client.send("Emulation.setDeviceMetricsOverride", {
-      width: viewport.width,
-      height: viewport.height,
-      deviceScaleFactor: 1,
-      mobile: false
-    });
-    await new Promise((r) => setTimeout(r, 150));
-  }
-  if (options?.fullPage) {
-    const layoutMetrics = await client.send("Page.getLayoutMetrics");
-    const contentWidth = layoutMetrics.cssVisualViewport?.clientWidth ?? viewport?.width ?? 1280;
-    const contentHeight = layoutMetrics.contentSize?.height ?? viewport?.height ?? 800;
-    await client.send("Emulation.setDeviceMetricsOverride", {
-      width: contentWidth,
-      height: Math.ceil(contentHeight),
-      deviceScaleFactor: 1,
-      mobile: false
-    });
-    await new Promise((r) => setTimeout(r, 150));
-  }
-  let screenshotOpts = {
-    format: "png",
-    captureBeyondViewport: false
-  };
-  try {
-    const metrics = await client.send("Page.getLayoutMetrics");
-    const vw = metrics.cssVisualViewport?.clientWidth ?? 0;
-    const vh = metrics.cssVisualViewport?.clientHeight ?? 0;
-    const sx = metrics.cssVisualViewport?.pageX ?? 0;
-    const sy = metrics.cssVisualViewport?.pageY ?? 0;
-    const dprResult = await client.send("Runtime.evaluate", {
-      expression: "window.devicePixelRatio",
-      returnByValue: true
-    });
-    const dpr = dprResult.result.value ?? 1;
-    const actualMaxSide = Math.max(vw, vh) * dpr;
-    const scale = actualMaxSide > MAX_DIM ? MAX_DIM / actualMaxSide : 1 / dpr;
-    screenshotOpts = {
-      ...screenshotOpts,
-      clip: { x: sx, y: sy, width: vw, height: vh, scale }
-    };
-  } catch {
-  }
-  const result = await client.send(
-    "Page.captureScreenshot",
-    screenshotOpts
-  );
-  if (viewport || options?.fullPage) {
-    await client.send("Emulation.clearDeviceMetricsOverride");
-  }
-  return Buffer.from(result.data, "base64");
-}
-async function getAccessibilityTree(client) {
-  await client.send("Accessibility.enable");
-  const result = await client.send("Accessibility.getFullAXTree");
-  await client.send("Accessibility.disable");
-  const nodeMap = /* @__PURE__ */ new Map();
-  for (const node of result.nodes) {
-    nodeMap.set(node.nodeId, node);
-  }
-  const SKIP_ROLES = /* @__PURE__ */ new Set(["none", "generic", "InlineTextBox"]);
-  function buildNode(node) {
-    const role = node.role?.value ?? "";
-    const childNodes = (node.childIds ?? []).flatMap((id) => {
-      const child = nodeMap.get(id);
-      return child ? buildNode(child) : [];
-    });
-    if (SKIP_ROLES.has(role)) {
-      return childNodes;
-    }
-    return [
-      {
-        role,
-        name: node.name?.value ?? "",
-        children: childNodes
-      }
-    ];
+var fs3;
+var init_har_output = __esm({
+  "src/cdp/har-output.ts"() {
+    fs3 = __toESM(require("fs"));
   }
-  const root = result.nodes[0];
-  return root ? buildNode(root) : [];
-}
+});
+
+// src/cdp/execute.ts
 async function executeInBrowser(code, options = {}) {
   const port = options.port ?? await detectCdpPort();
   if (!options.targetId) {
@@ -4421,6 +4406,19 @@ async function executeInBrowser(code, options = {}) {
     };
   }
 }
+var init_execute = __esm({
+  "src/cdp/execute.ts"() {
+    init_client();
+    init_detect();
+    init_targets();
+    init_console_recorder();
+    init_har_recorder();
+    init_console_recorder();
+    init_har_output();
+  }
+});
+
+// src/cdp/record.ts
 async function recordTraffic(options) {
   const port = options.port ?? await detectCdpPort();
   const duration = options.duration ?? 10;
@@ -4493,14 +4491,14 @@ async function navigateAndRecord(options) {
   try {
     await Promise.race([
       (async () => {
-        await new Promise((resolve2) => {
+        await new Promise((resolve4) => {
           const timer = setTimeout(() => {
             console.error("Page load timeout (10s), continuing with settle...");
-            resolve2();
+            resolve4();
           }, 1e4);
           client.on("Page.loadEventFired", () => {
             clearTimeout(timer);
-            resolve2();
+            resolve4();
           });
         });
         console.error(`Settling for ${settle}ms...`);
@@ -4541,14 +4539,14 @@ async function navigateAndWait(port, url, options = {}) {
   const client = new CDPClient(tab.webSocketDebuggerUrl);
   await client.waitReady();
   await client.send("Page.enable");
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve4, reject) => {
     const timer = setTimeout(
       () => reject(new Error(`Page load timeout: ${url}`)),
       timeout
     );
     client.on("Page.loadEventFired", () => {
       clearTimeout(timer);
-      resolve2();
+      resolve4();
     });
   });
   client.close();
@@ -4556,8 +4554,19 @@ async function navigateAndWait(port, url, options = {}) {
   const refreshed = targets.find((t) => t.id === tab.id);
   return refreshed ?? tab;
 }
+var init_record = __esm({
+  "src/cdp/record.ts"() {
+    init_client();
+    init_detect();
+    init_targets();
+    init_har_recorder();
+    init_har_output();
+  }
+});
+
+// src/cdp/tab-lock.ts
 function lockPath(tabId) {
-  return path3.join(LOCK_DIR, `capture-cdp-tab-${tabId}.lock`);
+  return path2.join(LOCK_DIR, `capture-cdp-tab-${tabId}.lock`);
 }
 function isPidAlive(pid) {
   try {
@@ -4569,7 +4578,7 @@ function isPidAlive(pid) {
 }
 function isLockStale(filePath) {
   try {
-    const content = fs3.readFileSync(filePath, "utf-8");
+    const content = fs4.readFileSync(filePath, "utf-8");
     const { pid, ts } = JSON.parse(content);
     if (!isPidAlive(pid)) return true;
     return Date.now() - ts > LOCK_STALE_MS;
@@ -4583,7 +4592,7 @@ function registerCleanup() {
   const cleanup = () => {
     for (const file of heldLocks) {
       try {
-        fs3.unlinkSync(file);
+        fs4.unlinkSync(file);
       } catch {
       }
     }
@@ -4606,9 +4615,9 @@ async function acquireTabLock(tabId) {
   let delay = LOCK_POLL_BASE_MS;
   while (true) {
     try {
-      const fd = fs3.openSync(file, "wx");
-      fs3.writeSync(fd, JSON.stringify({ pid: process.pid, ts: Date.now() }));
-      fs3.closeSync(fd);
+      const fd = fs4.openSync(file, "wx");
+      fs4.writeSync(fd, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+      fs4.closeSync(fd);
       heldLocks.add(file);
       return;
     } catch (err) {
@@ -4616,7 +4625,7 @@ async function acquireTabLock(tabId) {
     }
     if (isLockStale(file)) {
       try {
-        fs3.unlinkSync(file);
+        fs4.unlinkSync(file);
       } catch {
       }
       continue;
@@ -4633,7 +4642,7 @@ async function acquireTabLock(tabId) {
 function isTabLocked(tabId) {
   const file = lockPath(tabId);
   try {
-    fs3.accessSync(file);
+    fs4.accessSync(file);
     return !isLockStale(file);
   } catch {
     return false;
@@ -4643,7 +4652,7 @@ function releaseTabLock(tabId) {
   const file = lockPath(tabId);
   heldLocks.delete(file);
   try {
-    fs3.unlinkSync(file);
+    fs4.unlinkSync(file);
   } catch {
   }
 }
@@ -4655,588 +4664,124 @@ async function withTabLock(tabId, fn) {
     releaseTabLock(tabId);
   }
 }
-async function autoScreenshot(client, action, label, noScreenshot) {
-  if (noScreenshot) return null;
-  const shotPath = nextStepPath(action, label);
-  if (!shotPath) return null;
-  await new Promise((r) => setTimeout(r, 300));
-  const png = await captureScreenshot(client);
-  fs3.writeFileSync(shotPath, png);
-  console.error(`  [screenshot] ${shotPath}`);
-  return shotPath;
-}
-async function main() {
-  const args = process.argv.slice(2);
-  const parsed = parseCliArgs(args);
-  switch (parsed.command) {
-    case "detect": {
-      if (parsed.help) {
-        console.log(
-          "Usage: capture detect\n\nDetect CDP port (prioritizes default browser).\nReturns JSON with port, app name, and all discovered endpoints."
-        );
-        process.exit(0);
-      }
-      const endpoints = await detectCdpPortsAsync();
-      if (endpoints.length === 0) {
-        console.error(
-          "ERROR: No browser with CDP found.\n\nFix: Start a browser with remote debugging enabled:\n  Arc: Already enabled by default\n  Chrome: --remote-debugging-port=9222\n  Electron apps expose CDP automatically"
-        );
-        process.exit(1);
-      }
-      const defaultBrowser = getDefaultBrowserId();
-      const preferred = endpoints.find(
-        (p) => p.bundleId === defaultBrowser && !p.isElectron
-      ) ?? endpoints.find((p) => !p.isElectron) ?? endpoints[0];
-      console.log(
-        JSON.stringify(
-          {
-            port: preferred.port,
-            app: preferred.app,
-            isElectron: preferred.isElectron,
-            all: endpoints.map((e) => ({
-              port: e.port,
-              app: e.app,
-              isElectron: e.isElectron
-            }))
-          },
-          null,
-          2
-        )
-      );
-      console.error(
-        `
-Found ${endpoints.length} CDP endpoint${endpoints.length > 1 ? "s" : ""}. Default: port ${preferred.port} (${preferred.app}).
+var fs4, os2, path2, LOCK_DIR, LOCK_STALE_MS, LOCK_TIMEOUT_MS, LOCK_POLL_BASE_MS, heldLocks, cleanupRegistered;
+var init_tab_lock = __esm({
+  "src/cdp/tab-lock.ts"() {
+    fs4 = __toESM(require("fs"));
+    os2 = __toESM(require("os"));
+    path2 = __toESM(require("path"));
+    LOCK_DIR = os2.tmpdir();
+    LOCK_STALE_MS = 12e4;
+    LOCK_TIMEOUT_MS = 6e4;
+    LOCK_POLL_BASE_MS = 200;
+    heldLocks = /* @__PURE__ */ new Set();
+    cleanupRegistered = false;
+  }
+});
 
-Next (most tasks): capture session start --url <your app url>
-      (one-off):    capture list --port ${preferred.port}`
-      );
-      break;
+// src/cdp/args.ts
+function parseCliArgs(argv) {
+  const command = argv[0] ?? "";
+  const positional = [];
+  const parsed = { command, positional };
+  for (let i = 1; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    if (arg === "--port" && next) {
+      parsed.port = parseInt(next, 10);
+      i++;
+    } else if (arg === "--out" && next) {
+      parsed.out = next;
+      i++;
+    } else if (arg === "--json") {
+      parsed.json = true;
+    } else if (arg === "--interactive") {
+      parsed.interactive = true;
+    } else if (arg === "--har-out" && next) {
+      parsed.harOut = next;
+      i++;
+    } else if (arg === "--record") {
+      parsed.record = true;
+    } else if (arg === "--duration" && next) {
+      parsed.duration = parseInt(next, 10);
+      i++;
+    } else if (arg === "--settle" && next) {
+      parsed.settle = parseInt(next, 10);
+      i++;
+    } else if (arg === "--file" && next) {
+      parsed.file = next;
+      i++;
+    } else if (arg === "--nested") {
+      parsed.nested = true;
+    } else if (arg === "--har" && next) {
+      parsed.har = next;
+      i++;
+    } else if (arg === "--new") {
+      parsed.new = true;
+    } else if (arg === "--target" && next) {
+      parsed.target = next;
+      i++;
+    } else if (arg === "--role" && next) {
+      parsed.role = next;
+      i++;
+    } else if (arg === "--into" && next) {
+      parsed.into = next;
+      i++;
+    } else if (arg === "--no-screenshot") {
+      parsed.noScreenshot = true;
+    } else if (arg === "--viewport" && next) {
+      parsed.viewport = next;
+      i++;
+    } else if (arg === "--full-page") {
+      parsed.fullPage = true;
+    } else if (arg === "--height" && next) {
+      parsed.height = parseInt(next, 10);
+      i++;
+    } else if (arg === "--filter-url" && next) {
+      parsed.filterUrl = next;
+      i++;
+    } else if (arg === "--filter-status" && next) {
+      parsed.filterStatus = next;
+      i++;
+    } else if (arg === "--filter-method" && next) {
+      parsed.filterMethod = next.toUpperCase();
+      i++;
+    } else if (arg === "--limit" && next) {
+      parsed.limit = parseInt(next, 10);
+      i++;
+    } else if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+    } else if (arg.startsWith("--")) {
+      console.error(`Unknown flag: ${arg}`);
+      process.exit(1);
+    } else {
+      positional.push(arg);
     }
-    case "list": {
-      if (parsed.help) {
-        console.log(
-          "Usage: capture list [--port <port>]\n\nList all browser tabs across all CDP endpoints (or a specific port).\nReturns JSON array of {id, title, url, port, app}."
-        );
-        process.exit(0);
-      }
-      if (parsed.port) {
-        const targets = await listTargets(parsed.port);
-        const pages = targets.filter((t) => t.type === "page");
-        console.log(JSON.stringify(pages.map((t) => ({
-          id: t.id,
-          title: t.title,
-          url: t.url
-        })), null, 2));
-        console.error(
-          `
-${pages.length} tab${pages.length !== 1 ? "s" : ""} on port ${parsed.port}.
-
-Target a tab with: --target <id prefix>  (first 8 chars sufficient)`
-        );
-      } else {
-        const endpoints = await detectCdpPortsAsync();
-        if (endpoints.length === 0) {
-          console.error("No CDP endpoints found.");
-          process.exit(1);
-        }
-        const allPages = [];
-        await Promise.all(endpoints.map(async (ep) => {
-          try {
-            const targets = await listTargets(ep.port);
-            const pages = targets.filter((t) => t.type === "page");
-            for (const t of pages) {
-              allPages.push({ id: t.id, title: t.title, url: t.url, port: ep.port, app: ep.app });
-            }
-          } catch {
-          }
-        }));
-        console.log(JSON.stringify(allPages, null, 2));
-        console.error(
-          `
-${allPages.length} tab${allPages.length !== 1 ? "s" : ""} across ${endpoints.length} CDP endpoint${endpoints.length !== 1 ? "s" : ""}.
-
-Target a tab with: --target <id prefix>  (first 8 chars sufficient)`
-        );
-      }
-      break;
-    }
-    case "open": {
-      if (parsed.help) {
-        console.log(
-          'Usage: capture open <url> [--new] [--port <port>]\n\nOpen URL in browser (returns tab ID).\n\nExample: capture open "https://app.example.com" --new'
-        );
-        process.exit(0);
-      }
-      const url = parsed.positional[0];
-      if (!url) {
-        console.error(
-          'ERROR: Missing URL.\n\nUsage: capture open <url> [--new] [--port <port>]\n\nExample: capture open "https://app.example.com" --new'
-        );
-        process.exit(1);
-      }
-      const p = parsed.port ?? await detectCdpPort();
-      const tab = await navigateAndWait(p, url, { forceNew: parsed.new });
-      console.log(JSON.stringify({
-        id: tab.id,
-        title: tab.title,
-        url: tab.url,
-        port: p
-      }, null, 2));
-      console.error(
-        `
-Opened: ${tab.title || url}
-
-For a multi-step validation, prefer a session (auto-targets this kind of tab):
-  capture session start --url "${url}"
-
-Or interact one-off against this tab:
-  capture a11y       --port ${p} --target ${tab.id.slice(0, 8)} --interactive
-  capture screenshot --port ${p} --target ${tab.id.slice(0, 8)}
-  capture exec "<js>" --port ${p} --target ${tab.id.slice(0, 8)}`
-      );
-      break;
-    }
-    case "exec": {
-      if (parsed.help) {
-        console.log(
-          `Usage: capture exec <code> [--target <id>] [--record] [--file <path>] [--har <id>]
-
-Execute JavaScript in a browser tab. Supports await (wrapped in async IIFE).
-
-Examples:
-  capture exec "document.title" --target <id>
-  capture exec "await fetch('/api/data').then(r=>r.json())" --target <id>
-  capture exec "document.querySelector('.btn').click()" --target <id>
-  capture exec --file /tmp/scrape.js --target <id> --record`
-        );
-        process.exit(0);
-      }
-      let code;
-      if (parsed.file) {
-        code = fs3.readFileSync(parsed.file, "utf-8");
-      } else {
-        code = parsed.positional[0];
-        if (!code) {
-          console.error(
-            `ERROR: Missing code to execute.
-
-Usage: capture exec <code> [--target <id>] [--record] [--file <path>]
+  }
+  if (!parsed.target && process.env.CDP_TARGET) {
+    parsed.target = process.env.CDP_TARGET;
+  }
+  if (!parsed.har && process.env.CDP_HAR_ID) {
+    parsed.har = process.env.CDP_HAR_ID;
+  }
+  const session = getActiveSession();
+  if (session) {
+    if (!parsed.har && session.harId) parsed.har = session.harId;
+    if (!parsed.target && session.targetId) parsed.target = session.targetId;
+  }
+  return parsed;
+}
+var init_args = __esm({
+  "src/cdp/args.ts"() {
+    init_session_context();
+  }
+});
 
-Examples:
-  capture exec "document.title" --target <id>
-  capture exec "document.querySelector('.btn').click()" --target <id>
-  capture exec --file /tmp/scrape.js --target <id> --record`
-          );
-          process.exit(1);
-        }
-      }
-      await withConnection(
-        parsed,
-        async (client) => {
-          await client.send("Emulation.setFocusEmulationEnabled", { enabled: true });
-          let standaloneRecorder;
-          if (parsed.record) {
-            standaloneRecorder = new HARRecorder(client);
-            await standaloneRecorder.start();
-          }
-          const needsAsyncWrap = /\bawait\b/.test(code);
-          const expression = needsAsyncWrap ? `(async () => { ${code} })()` : code;
-          const evalResult = await client.send("Runtime.evaluate", {
-            expression,
-            awaitPromise: true,
-            returnByValue: true
-          });
-          if (standaloneRecorder) {
-            const har = await standaloneRecorder.finish();
-            writeHarAndPrintSummary(har, parsed.harOut);
-          }
-          if (evalResult.exceptionDetails) {
-            console.error(
-              `ERROR: ${evalResult.exceptionDetails.exception?.description ?? "Unknown error"}`
-            );
-            process.exit(1);
-          }
-          console.log(JSON.stringify(evalResult.result?.value));
-        },
-        { settle: 3e3 }
-      );
-      break;
-    }
-    case "record": {
-      if (parsed.help) {
-        console.log(
-          "Usage: capture record --target <id> [--duration <secs>] [--har-out <path>]\n\nPassive HAR recording for the specified duration (default: 10s)."
-        );
-        process.exit(0);
-      }
-      if (!parsed.target) {
-        console.error(
-          "Usage: capture record --target <id> [--duration <secs>] [--har-out <path>]"
-        );
-        process.exit(1);
-      }
-      const result = await recordTraffic({
-        port: parsed.port,
-        targetId: parsed.target,
-        duration: parsed.duration,
-        harOutPath: parsed.harOut
-      });
-      console.log(
-        JSON.stringify(
-          { entryCount: result.entryCount, harPath: result.harPath },
-          null,
-          2
-        )
-      );
-      break;
-    }
-    case "reset-tab": {
-      if (parsed.help) {
-        console.log(
-          'Usage: capture reset-tab <url> [--port <port>]\n\nAbandon a stuck/unresponsive tab and open a fresh one.\nUpdates session context so subsequent commands auto-target the new tab.\n\nExample: capture reset-tab "https://www.instagram.com/"'
-        );
-        process.exit(0);
-      }
-      const url = parsed.positional[0];
-      if (!url) {
-        console.error(
-          "Usage: capture reset-tab <url> [--port <port>]"
-        );
-        process.exit(1);
-      }
-      const p = parsed.port ?? await detectCdpPort();
-      const tab = await openTab(p, url);
-      if (tab.webSocketDebuggerUrl) {
-        const client = new CDPClient(tab.webSocketDebuggerUrl);
-        await client.waitReady();
-        await client.send("Page.enable");
-        await new Promise((resolve2) => {
-          const timer = setTimeout(() => resolve2(), 1e4);
-          client.on("Page.loadEventFired", () => {
-            clearTimeout(timer);
-            resolve2();
-          });
-        });
-        client.close();
-      }
-      updateActiveSession({ targetId: tab.id });
-      console.log(JSON.stringify({ id: tab.id, url: tab.url, port: p }, null, 2));
-      console.error(`
-New tab opened. Session context updated.`);
-      console.error(`Use --target ${tab.id.slice(0, 8)} if passing target explicitly.`);
-      break;
-    }
-    case "navigate": {
-      if (parsed.help) {
-        console.log(
-          'Usage: capture navigate <url> [--har-out <path>] [--settle <ms>] [--har <id>]\n\nNavigate to URL and record HAR. Appends to session HAR if --har is set.\n\nExample: capture navigate "https://app.example.com/dashboard" --settle 3000'
-        );
-        process.exit(0);
-      }
-      const url = parsed.positional[0];
-      if (!url) {
-        console.error(
-          "Usage: capture navigate <url> [--har-out <path>] [--settle <ms>]"
-        );
-        process.exit(1);
-      }
-      const result = await navigateAndRecord({
-        port: parsed.port,
-        url,
-        targetId: parsed.target,
-        harOutPath: parsed.har ? void 0 : parsed.harOut,
-        settle: parsed.settle
-      });
-      if (parsed.har && result.har.log.entries.length > 0) {
-        appendToHarRecording(parsed.har, result.har.log.entries);
-        console.error(`  [har:${parsed.har}] +${result.har.log.entries.length} entries`);
-      }
-      console.log(
-        JSON.stringify(
-          {
-            entryCount: result.entryCount,
-            harPath: result.harPath,
-            tabUrl: result.tab.url,
-            timedOut: result.timedOut
-          },
-          null,
-          2
-        )
-      );
-      break;
-    }
-    case "screenshot": {
-      if (parsed.help) {
-        console.log(
-          "Usage: capture screenshot [--target <id>] [--out <path>] [--viewport <preset>] [--height <px>] [--full-page]\n\nCapture a screenshot of the targeted tab. Saves to --out or auto-generates a path.\n\nOptions:\n  --viewport <preset>  Viewport preset (default: desktop)\n                       desktop-wide  1920x1080\n                       desktop       1280x800\n                       tablet        768x1024\n                       mobile        390x844\n  --height <px>        Override viewport height (e.g. 1600)\n  --full-page          Capture the entire scrollable page"
-        );
-        process.exit(0);
-      }
-      const VIEWPORTS = {
-        "desktop-wide": { width: 1920, height: 1080 },
-        "desktop": { width: 1280, height: 800 },
-        "tablet": { width: 768, height: 1024 },
-        "mobile": { width: 390, height: 844 }
-      };
-      const viewportName = parsed.viewport ?? "desktop";
-      const viewport = VIEWPORTS[viewportName];
-      if (!viewport) {
-        console.error(`Unknown viewport "${viewportName}". Options: ${Object.keys(VIEWPORTS).join(", ")}`);
-        process.exit(1);
-      }
-      if (parsed.height) {
-        viewport.height = parsed.height;
-      }
-      const result = await withConnection(
-        parsed,
-        async (client) => {
-          const png = await captureScreenshot(client, viewport, { fullPage: parsed.fullPage });
-          const outPath = parsed.out ? parsed.out : nextStepPath("screenshot", "manual") ?? `/tmp/capture-screenshot-${Date.now()}.png`;
-          fs3.writeFileSync(outPath, png);
-          return { path: outPath, bytes: png.length };
-        },
-        { settle: 0 }
-      );
-      console.log(JSON.stringify(result, null, 2));
-      break;
-    }
-    case "click": {
-      if (parsed.help) {
-        console.log(
-          'Usage: capture click "name" [--role button|link|...] [--no-screenshot]\n\nClick an element by its accessible name. Auto-captures a screenshot after clicking.'
-        );
-        process.exit(0);
-      }
-      const name = parsed.positional[0];
-      if (!name) {
-        console.error('Usage: capture click "name" [--role button|link|...] [--no-screenshot]');
-        process.exit(1);
-      }
-      const clickSettle = parsed.settle !== void 0 ? parsed.settle : parsed.har ? 2500 : 1e3;
-      const result = await withConnection(
-        parsed,
-        async (client) => {
-          const clickResult = await clickByName(client, name, parsed.role);
-          const screenshot = await autoScreenshot(client, "click", name, parsed.noScreenshot);
-          return { ...clickResult, screenshot };
-        },
-        { settle: clickSettle }
-      );
-      console.log(JSON.stringify(result, null, 2));
-      break;
-    }
-    case "type": {
-      if (parsed.help) {
-        console.log(
-          'Usage: capture type "text" [--into "field name"] [--no-screenshot]\n\nType text into the focused element, or into a named field with --into.'
-        );
-        process.exit(0);
-      }
-      const text = parsed.positional[0];
-      if (!text) {
-        console.error('Usage: capture type "text" [--into "field name"] [--no-screenshot]');
-        process.exit(1);
-      }
-      const result = await withConnection(
-        parsed,
-        async (client) => {
-          let field = null;
-          if (parsed.into) {
-            await focusAndType(client, parsed.into, text, parsed.role);
-            field = parsed.into;
-          } else {
-            await typeText(client, text);
-          }
-          const label = field ?? text;
-          const screenshot = await autoScreenshot(client, "type", label, parsed.noScreenshot);
-          return { typed: text, field, screenshot };
-        },
-        { settle: parsed.settle !== void 0 ? parsed.settle : parsed.har ? 1500 : 500 }
-      );
-      console.log(JSON.stringify(result, null, 2));
-      break;
-    }
-    case "a11y": {
-      if (parsed.help) {
-        console.log(
-          "Usage: capture a11y [--target <id>] [--json] [--interactive]\n\nGet the accessibility tree. Use --interactive for interactive elements only.\nUse --json for structured JSON output."
-        );
-        process.exit(0);
-      }
-      const result = await withConnection(
-        parsed,
-        async (client) => {
-          const tree = await getAccessibilityTree(client);
-          if (parsed.json) {
-            return tree;
-          }
-          const lines = flattenA11yTree(tree, {
-            interactive: parsed.interactive
-          });
-          return lines.join("\n");
-        },
-        { settle: 0 }
-      );
-      if (parsed.json) {
-        console.log(JSON.stringify(result, null, 2));
-      } else {
-        console.log(result);
-      }
-      if (!parsed.json) {
-        const lineCount = typeof result === "string" ? result.split("\n").filter(Boolean).length : 0;
-        if (lineCount === 0) {
-          console.error(
-            "\nNo elements found." + (parsed.interactive ? " Try without --interactive to see all nodes." : "") + '\n\nIf this page is part of your project, consider adding ARIA attributes:\n  - role="button|link|textbox" on interactive elements\n  - aria-label="..." on elements without visible text\n  - Semantic HTML (<button>, <input>, <nav>) provides roles automatically'
-          );
-        } else if (parsed.interactive && lineCount < 5) {
-          console.error(
-            `
-Only ${lineCount} interactive element${lineCount === 1 ? "" : "s"} found. If this seems low, the page may lack ARIA markup.
-Consider adding role and aria-label attributes to interactive elements in your frontend code.`
-          );
-        }
-      }
-      break;
-    }
-    case "har": {
-      if (parsed.help) {
-        console.log(
-          "Usage: capture har <create|read|delete>\n\n  create                      Create a new HAR recording (returns id)\n  read [id]                   Read accumulated HAR entries (id optional in active session)\n  delete <id>                 Delete a HAR recording\n\nFilters (read):\n  --filter-url <pattern>      Substring or regex match on URL\n  --filter-status <code>      Status code, prefix (e.g. 4), or range (e.g. 400-499)\n  --filter-method <method>    HTTP method (GET, POST, ...)\n  --limit <N>                 Return only the first N matching entries\n\nPass --har <id> to exec/navigate commands to append traffic to a recording."
-        );
-        process.exit(0);
-      }
-      const subcommand = args[1];
-      if (subcommand === "create") {
-        const { id, path: harPath } = createHarRecording();
-        console.log(JSON.stringify({ id, path: harPath }, null, 2));
-        console.error(
-          `
-Pass --har ${id} to subsequent commands to record traffic.`
-        );
-        break;
-      }
-      if (subcommand === "read") {
-        let id = args[2];
-        if (id && id.startsWith("--")) id = void 0;
-        if (!id) {
-          const session = getActiveSession();
-          if (session?.harId) {
-            id = session.harId;
-          } else {
-            console.error("Usage: capture har read [id]\n  ID is optional when a capture session is active.");
-            process.exit(1);
-          }
-        }
-        const har = readHarRecording(id);
-        if (!har) {
-          console.error(`No HAR recording found for id: ${id}`);
-          process.exit(1);
-        }
-        let entries = har.log.entries;
-        const total = entries.length;
-        const filters = [];
-        if (parsed.filterUrl) {
-          const pattern = parsed.filterUrl;
-          let re = null;
-          try {
-            re = new RegExp(pattern, "i");
-          } catch {
-            re = null;
-          }
-          entries = entries.filter(
-            (e) => re ? re.test(e.request.url) : e.request.url.toLowerCase().includes(pattern.toLowerCase())
-          );
-          filters.push(`url~${pattern}`);
-        }
-        if (parsed.filterStatus) {
-          const s = parsed.filterStatus;
-          let matcher;
-          if (/^\d+-\d+$/.test(s)) {
-            const [lo, hi] = s.split("-").map((n) => parseInt(n, 10));
-            matcher = (c) => c >= lo && c <= hi;
-          } else if (/^\d+$/.test(s)) {
-            if (s.length < 3) {
-              matcher = (c) => String(c).startsWith(s);
-            } else {
-              const n = parseInt(s, 10);
-              matcher = (c) => c === n;
-            }
-          } else {
-            matcher = () => true;
-          }
-          entries = entries.filter((e) => matcher(e.response.status));
-          filters.push(`status=${s}`);
-        }
-        if (parsed.filterMethod) {
-          const m = parsed.filterMethod;
-          entries = entries.filter((e) => e.request.method.toUpperCase() === m);
-          filters.push(`method=${m}`);
-        }
-        if (typeof parsed.limit === "number" && parsed.limit > 0) {
-          entries = entries.slice(0, parsed.limit);
-          filters.push(`limit=${parsed.limit}`);
-        }
-        const filtersLabel = filters.length > 0 ? `  [${filters.join(", ")}]` : "";
-        console.error(
-          `HAR: ${harFilePath(id)} (${entries.length}/${total} entries)${filtersLabel}`
-        );
-        console.log(JSON.stringify({ log: { entries } }, null, 2));
-        break;
-      }
-      if (subcommand === "delete") {
-        const id = args[2];
-        if (!id) {
-          console.error("Usage: capture har delete <id>");
-          process.exit(1);
-        }
-        deleteHarRecording(id);
-        console.log(JSON.stringify({ deleted: true, id }, null, 2));
-        break;
-      }
-      console.error(
-        "Usage: capture har <create|read|delete>\n  create              Create a new HAR recording (returns id)\n  read <id>           Read accumulated HAR entries\n  delete <id>         Delete a HAR recording"
-      );
-      process.exit(1);
-      break;
-    }
-    case "network": {
-      if (parsed.help) {
-        console.log(
-          'Usage: capture network <offline|online> [--target <id>]\n\nToggle network connectivity for a tab. Use "offline" to simulate\nnetwork failure (kills WebSocket connections, blocks HTTP requests).\nUse "online" to restore connectivity.'
-        );
-        process.exit(0);
-      }
-      const mode = parsed.positional[0];
-      if (!mode || !["offline", "online"].includes(mode)) {
-        console.error("Usage: capture network <offline|online> [--target <id>]");
-        process.exit(1);
-      }
-      const offline = mode === "offline";
-      const result = await withConnection(
-        parsed,
-        async (client) => {
-          await client.send("Network.enable");
-          await client.send("Network.emulateNetworkConditions", {
-            offline,
-            latency: offline ? -1 : 0,
-            downloadThroughput: offline ? 0 : -1,
-            uploadThroughput: offline ? 0 : -1
-          });
-          return { network: mode, offline };
-        },
-        { settle: 0 }
-      );
-      console.log(JSON.stringify(result, null, 2));
-      if (offline) {
-        console.error("\nNetwork disabled. WebSocket connections will drop.");
-        console.error("Restore with: capture network online");
-      } else {
-        console.error("\nNetwork restored.");
-      }
-      break;
-    }
-    default:
-      console.log(`CDP \u2014 browser automation via exec, a11y interactions, and screenshots.
+// src/cdp/usage.ts
+var CDP_USAGE;
+var init_usage = __esm({
+  "src/cdp/usage.ts"() {
+    CDP_USAGE = `CDP \u2014 browser automation via exec, a11y interactions, and screenshots.
 
 Commands:
   exec <code>         Execute JavaScript in a browser tab
@@ -5255,6 +4800,10 @@ Commands:
   har create          Create a HAR recording (returns id)
   har read [id]       Read accumulated HAR entries (id optional in active session)
   har delete <id>     Delete a HAR recording
+  lib list            List available vault libs (dev checkout only)
+  lib search "<q>"     Fuzzy-search lib functions [--limit N]
+  lib show <name>     Lib + function summaries
+  lib read <name> [fn\u2026]  Full input/output schemas (+ .ts source path)
 
 Options:
   --port <port>       Override CDP port
@@ -5297,246 +4846,1498 @@ Examples:
   capture har create
   capture exec "document.querySelector('form').submit()" --target <id> --har <id>
   capture har read <id>
-`);
+  capture lib search "search emails"
+  capture lib read gmail searchEmails
+  capture exec "import {searchEmails} from 'libs/gmail'; const ctx = await getContext(); return await searchEmails({ ...ctx, query: 'invoice' })"
+`;
+  }
+});
+
+// src/cdp/commands/tabs.ts
+async function cmdDetect(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      "Usage: capture detect\n\nDetect CDP port (prioritizes default browser).\nReturns JSON with port, app name, and all discovered endpoints."
+    );
+    process.exit(0);
+  }
+  const endpoints = await detectCdpPortsAsync();
+  if (endpoints.length === 0) {
+    console.error(
+      "ERROR: No browser with CDP found.\n\nFix: Start a browser with remote debugging enabled:\n  Arc: Already enabled by default\n  Chrome: --remote-debugging-port=9222\n  Electron apps expose CDP automatically"
+    );
+    process.exit(1);
   }
+  const defaultBrowser = getDefaultBrowserId();
+  const preferred = endpoints.find(
+    (p) => p.bundleId === defaultBrowser && !p.isElectron
+  ) ?? endpoints.find((p) => !p.isElectron) ?? endpoints[0];
+  console.log(
+    JSON.stringify(
+      {
+        port: preferred.port,
+        app: preferred.app,
+        isElectron: preferred.isElectron,
+        all: endpoints.map((e) => ({
+          port: e.port,
+          app: e.app,
+          isElectron: e.isElectron
+        }))
+      },
+      null,
+      2
+    )
+  );
+  console.error(
+    `
+Found ${endpoints.length} CDP endpoint${endpoints.length > 1 ? "s" : ""}. Default: port ${preferred.port} (${preferred.app}).
+
+Next (most tasks): capture session start --url <your app url>
+      (one-off):    capture list --port ${preferred.port}`
+  );
+  return;
 }
-var import_child_process, fs3, os2, path3, SKIP_EXTENSIONS, SKIP_DOMAINS, MAX_BODY_SIZE, HARRecorder, ConsoleRecorder, INTERACTIVE_ROLES, BROWSER_PATTERNS, CDPClient, LOCK_DIR, LOCK_STALE_MS, LOCK_TIMEOUT_MS, LOCK_POLL_BASE_MS, heldLocks, cleanupRegistered, isMainModule;
-var init_cdp = __esm({
-  "src/cdp.ts"() {
-    import_child_process = require("child_process");
-    fs3 = __toESM(require("fs"));
-    os2 = __toESM(require("os"));
-    path3 = __toESM(require("path"));
-    init_wrapper();
-    init_har_manager();
-    init_session_context();
-    init_interact();
-    SKIP_EXTENSIONS = /\.(png|jpg|jpeg|gif|webp|svg|ico|woff2?|ttf|eot|css|mp4|webm|mp3)(\?|$)/i;
-    SKIP_DOMAINS = /(google-analytics|googletagmanager|doubleclick|facebook\.com\/tr|px\.ads|analytics|tracking|beacon|telemetry)/i;
-    MAX_BODY_SIZE = 256 * 1024;
-    HARRecorder = class {
-      constructor(client) {
-        this.client = client;
-      }
-      requests = /* @__PURE__ */ new Map();
-      responses = /* @__PURE__ */ new Map();
-      get responseCount() {
-        return this.responses.size;
+async function cmdList(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      "Usage: capture list [--port <port>]\n\nList all browser tabs across all CDP endpoints (or a specific port).\nReturns JSON array of {id, title, url, port, app}."
+    );
+    process.exit(0);
+  }
+  if (parsed.port) {
+    const targets = await listTargets(parsed.port);
+    const pages = targets.filter((t) => t.type === "page");
+    console.log(JSON.stringify(pages.map((t) => ({
+      id: t.id,
+      title: t.title,
+      url: t.url
+    })), null, 2));
+    console.error(
+      `
+${pages.length} tab${pages.length !== 1 ? "s" : ""} on port ${parsed.port}.
+
+Target a tab with: --target <id prefix>  (first 8 chars sufficient)`
+    );
+  } else {
+    const endpoints = await detectCdpPortsAsync();
+    if (endpoints.length === 0) {
+      console.error("No CDP endpoints found.");
+      process.exit(1);
+    }
+    const allPages = [];
+    await Promise.all(endpoints.map(async (ep) => {
+      try {
+        const targets = await listTargets(ep.port);
+        const pages = targets.filter((t) => t.type === "page");
+        for (const t of pages) {
+          allPages.push({ id: t.id, title: t.title, url: t.url, port: ep.port, app: ep.app });
+        }
+      } catch {
       }
-      async start() {
-        await this.client.send("Network.enable");
-        this.client.on("Network.requestWillBeSent", (params) => {
-          const p = params;
-          if (!shouldRecordRequest(p.request.url)) return;
-          this.requests.set(p.requestId, {
-            requestId: p.requestId,
-            url: p.request.url,
-            method: p.request.method,
-            headers: p.request.headers,
-            postData: p.request.postData,
-            timestamp: p.timestamp
-          });
-        });
-        this.client.on("Network.responseReceived", (params) => {
-          const p = params;
-          if (!this.requests.has(p.requestId)) return;
-          this.responses.set(p.requestId, {
-            requestId: p.requestId,
-            url: p.response.url,
-            status: p.response.status,
-            headers: p.response.headers,
-            timestamp: p.timestamp
-          });
-        });
+    }));
+    console.log(JSON.stringify(allPages, null, 2));
+    console.error(
+      `
+${allPages.length} tab${allPages.length !== 1 ? "s" : ""} across ${endpoints.length} CDP endpoint${endpoints.length !== 1 ? "s" : ""}.
+
+Target a tab with: --target <id prefix>  (first 8 chars sufficient)`
+    );
+  }
+  return;
+}
+async function cmdOpen(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      'Usage: capture open <url> [--new] [--port <port>]\n\nOpen URL in browser (returns tab ID).\n\nExample: capture open "https://app.example.com" --new'
+    );
+    process.exit(0);
+  }
+  const url = parsed.positional[0];
+  if (!url) {
+    console.error(
+      'ERROR: Missing URL.\n\nUsage: capture open <url> [--new] [--port <port>]\n\nExample: capture open "https://app.example.com" --new'
+    );
+    process.exit(1);
+  }
+  const p = parsed.port ?? await detectCdpPort();
+  const tab = await navigateAndWait(p, url, { forceNew: parsed.new });
+  console.log(JSON.stringify({
+    id: tab.id,
+    title: tab.title,
+    url: tab.url,
+    port: p
+  }, null, 2));
+  console.error(
+    `
+Opened: ${tab.title || url}
+
+For a multi-step validation, prefer a session (auto-targets this kind of tab):
+  capture session start --url "${url}"
+
+Or interact one-off against this tab:
+  capture a11y       --port ${p} --target ${tab.id.slice(0, 8)} --interactive
+  capture screenshot --port ${p} --target ${tab.id.slice(0, 8)}
+  capture exec "<js>" --port ${p} --target ${tab.id.slice(0, 8)}`
+  );
+  return;
+}
+async function cmdResetTab(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      'Usage: capture reset-tab <url> [--port <port>]\n\nAbandon a stuck/unresponsive tab and open a fresh one.\nUpdates session context so subsequent commands auto-target the new tab.\n\nExample: capture reset-tab "https://www.instagram.com/"'
+    );
+    process.exit(0);
+  }
+  const url = parsed.positional[0];
+  if (!url) {
+    console.error(
+      "Usage: capture reset-tab <url> [--port <port>]"
+    );
+    process.exit(1);
+  }
+  const p = parsed.port ?? await detectCdpPort();
+  const tab = await openTab(p, url);
+  if (tab.webSocketDebuggerUrl) {
+    const client = new CDPClient(tab.webSocketDebuggerUrl);
+    await client.waitReady();
+    await client.send("Page.enable");
+    await new Promise((resolve4) => {
+      const timer = setTimeout(() => resolve4(), 1e4);
+      client.on("Page.loadEventFired", () => {
+        clearTimeout(timer);
+        resolve4();
+      });
+    });
+    client.close();
+  }
+  updateActiveSession({ targetId: tab.id });
+  console.log(JSON.stringify({ id: tab.id, url: tab.url, port: p }, null, 2));
+  console.error(`
+New tab opened. Session context updated.`);
+  console.error(`Use --target ${tab.id.slice(0, 8)} if passing target explicitly.`);
+  return;
+}
+var init_tabs = __esm({
+  "src/cdp/commands/tabs.ts"() {
+    init_detect();
+    init_targets();
+    init_record();
+    init_client();
+    init_session_context();
+  }
+});
+
+// src/har-manager.ts
+function harFilePath(id) {
+  return path3.join(HAR_DIR, `${id}.json`);
+}
+function createHarRecording() {
+  const id = Math.random().toString(36).slice(2, 8);
+  const harPath = harFilePath(id);
+  fs5.mkdirSync(HAR_DIR, { recursive: true });
+  fs5.writeFileSync(harPath, JSON.stringify({ log: { entries: [] } }, null, 2));
+  return { id, path: harPath };
+}
+function readHarRecording(id) {
+  try {
+    return JSON.parse(fs5.readFileSync(harFilePath(id), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function appendToHarRecording(id, entries) {
+  const harPath = harFilePath(id);
+  let har;
+  try {
+    har = JSON.parse(fs5.readFileSync(harPath, "utf-8"));
+  } catch {
+    har = { log: { entries: [] } };
+  }
+  har.log.entries.push(...entries);
+  fs5.writeFileSync(harPath, JSON.stringify(har, null, 2));
+}
+function deleteHarRecording(id) {
+  try {
+    fs5.unlinkSync(harFilePath(id));
+  } catch {
+  }
+}
+var fs5, path3, HAR_DIR;
+var init_har_manager = __esm({
+  "src/har-manager.ts"() {
+    fs5 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
+    HAR_DIR = "/tmp/capture-har";
+  }
+});
+
+// src/cdp/connection.ts
+async function connectForCommand(parsed) {
+  if (!parsed.target) {
+    throw new Error('Use --target <tabId> to target a tab. Run "capture list" to see available tabs.');
+  }
+  let tab = null;
+  if (parsed.port) {
+    tab = await findTabById(parsed.port, parsed.target);
+  } else {
+    const endpoints = await detectCdpPortsAsync();
+    for (const ep of endpoints) {
+      try {
+        tab = await findTabById(ep.port, parsed.target);
+        if (tab) break;
+      } catch {
       }
-      buildHar() {
-        return {
-          log: {
-            entries: Array.from(this.responses.values()).map((resp) => {
-              const req = this.requests.get(resp.requestId);
-              return {
-                startedDateTime: new Date(resp.timestamp * 1e3).toISOString(),
-                request: {
-                  method: req?.method ?? "GET",
-                  url: resp.url,
-                  headers: Object.entries(req?.headers ?? {}).map(
-                    ([name, value]) => ({ name, value })
-                  ),
-                  postData: req?.postData ? { text: req.postData } : void 0
-                },
-                response: {
-                  status: resp.status,
-                  headers: Object.entries(resp.headers).map(([name, value]) => ({
-                    name,
-                    value
-                  })),
-                  content: { text: resp.body }
-                }
-              };
-            })
-          }
-        };
+    }
+  }
+  if (!tab) {
+    const query = parsed.target;
+    throw new Error(
+      `No tab found for target "${query}". Run "capture list" to see available tabs.`
+    );
+  }
+  if (!tab.webSocketDebuggerUrl) {
+    throw new Error("Tab has no WebSocket debugger URL");
+  }
+  const activeSession = getActiveSession();
+  if (activeSession && !activeSession.targetId) {
+    updateActiveSession({ targetId: tab.id });
+  }
+  const client = new CDPClient(tab.webSocketDebuggerUrl);
+  await client.waitReady();
+  return { client, tab };
+}
+async function withConnection(parsed, fn, opts = {}) {
+  const { client, tab } = await connectForCommand(parsed);
+  const consoleRecorder = new ConsoleRecorder(client);
+  await consoleRecorder.start();
+  let harRecorder;
+  if (parsed.har) {
+    const harPath = harFilePath(parsed.har);
+    if (!fs6.existsSync(harPath)) {
+      console.error(
+        `ERROR: No HAR recording found for --har "${parsed.har}". Run 'har create' first.`
+      );
+      process.exit(1);
+    }
+    harRecorder = new HARRecorder(client);
+    await harRecorder.start();
+  }
+  try {
+    const result = await fn(client, tab);
+    if (harRecorder && parsed.har) {
+      const settle = opts.settle !== void 0 ? opts.settle : 3e3;
+      if (settle > 0) {
+        await new Promise((r) => setTimeout(r, settle));
       }
-      async finish() {
-        await Promise.allSettled(
-          Array.from(this.responses.entries()).map(async ([reqId, resp]) => {
-            const bodyResult = await this.client.send("Network.getResponseBody", {
-              requestId: reqId
-            }, 5e3);
-            const decoded = bodyResult.base64Encoded ? Buffer.from(bodyResult.body, "base64").toString() : bodyResult.body;
-            resp.body = decoded.length > MAX_BODY_SIZE ? decoded.slice(0, MAX_BODY_SIZE) + `
-[truncated: ${decoded.length} bytes]` : decoded;
-          })
+      const har = await harRecorder.finish();
+      if (har.log.entries.length > 0) {
+        appendToHarRecording(parsed.har, har.log.entries);
+        console.error(
+          `  [har:${parsed.har}] +${har.log.entries.length} entries`
         );
-        return this.buildHar();
-      }
-      finishPartial() {
-        return this.buildHar();
       }
-    };
-    ConsoleRecorder = class {
-      constructor(client) {
-        this.client = client;
+    }
+    printConsoleSummary(consoleRecorder.finish());
+    return result;
+  } finally {
+    client.close();
+  }
+}
+var fs6;
+var init_connection = __esm({
+  "src/cdp/connection.ts"() {
+    fs6 = __toESM(require("fs"));
+    init_client();
+    init_targets();
+    init_detect();
+    init_console_recorder();
+    init_har_recorder();
+    init_har_manager();
+    init_session_context();
+  }
+});
+
+// src/vault/paths.ts
+function vaultLibsDir() {
+  const candidates = [
+    path4.resolve(__dirname, "..", "vault", "libs"),
+    // built bin: bin/../vault/libs
+    path4.resolve(__dirname, "..", "..", "vault", "libs")
+    // tsx dev: src/vault/../../vault/libs
+  ];
+  const hit = candidates.find(
+    (p) => fs7.existsSync(path4.join(p, "_runtime", "index.ts"))
+  );
+  if (!hit) throw new Error(DEV_ONLY_MSG);
+  return hit;
+}
+function vaultRepoRoot() {
+  return path4.dirname(vaultLibsDir());
+}
+function listLibs() {
+  return fs7.readdirSync(vaultLibsDir(), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_")).map((e) => e.name).sort();
+}
+function unknownLibMsg(name) {
+  return `Unknown lib "${name}". Available: ${listLibs().join(", ")}`;
+}
+function isValidLibName(name) {
+  return VALID_LIB_NAME.test(name) && !name.includes("..");
+}
+async function loadEsbuild() {
+  return await import("esbuild").catch(() => {
+    throw new Error(DEV_ONLY_MSG);
+  });
+}
+var fs7, path4, DEV_ONLY_MSG, VALID_LIB_NAME;
+var init_paths = __esm({
+  "src/vault/paths.ts"() {
+    fs7 = __toESM(require("fs"));
+    path4 = __toESM(require("path"));
+    DEV_ONLY_MSG = "This is a dev-only feature of capture \u2014 run it from a capture checkout\n(vault/ source + `pnpm install`). Not available in the published package.";
+    VALID_LIB_NAME = /^[A-Za-z0-9_.-]+$/;
+  }
+});
+
+// src/vault/bundle.ts
+function splitLeadingImports(code) {
+  const imports = [];
+  let body = code;
+  for (; ; ) {
+    const m = IMPORT_STMT_RE.exec(body);
+    if (!m) break;
+    imports.push(m[0]);
+    body = body.slice(m[0].length);
+  }
+  return { imports: imports.join(""), body };
+}
+function hasImports(code) {
+  return splitLeadingImports(code).imports.length > 0;
+}
+function preflightLibs(imports) {
+  const libs = vaultLibsDir();
+  LIB_SPECIFIER_RE.lastIndex = 0;
+  let m;
+  while ((m = LIB_SPECIFIER_RE.exec(imports)) !== null) {
+    const name = m[2];
+    if (!isValidLibName(name) || !fs8.existsSync(path5.join(libs, name, "index.ts"))) {
+      throw new Error(unknownLibMsg(name));
+    }
+  }
+}
+function buildEntry(code) {
+  const { imports, body } = splitLeadingImports(code);
+  const expr = body.trim().replace(/;+\s*$/, "");
+  return [
+    imports,
+    `const ${SENTINEL} = (async () => { ${expr} })();`,
+    `${SENTINEL}.then();`
+  ].join("\n");
+}
+function vaultResolver() {
+  const libs = vaultLibsDir();
+  const runtime = path5.join(libs, "_runtime", "index.ts");
+  return {
+    name: "vault",
+    setup(build) {
+      build.onResolve({ filter: /^@vallum\/_runtime$/ }, () => ({
+        path: runtime
+      }));
+      build.onResolve({ filter: /^libs\// }, (args) => {
+        const name = args.path.slice("libs/".length);
+        if (!isValidLibName(name)) {
+          return { errors: [{ text: unknownLibMsg(name) }] };
+        }
+        const entry = path5.join(libs, name, "index.ts");
+        return fs8.existsSync(entry) ? { path: entry } : { errors: [{ text: unknownLibMsg(name) }] };
+      });
+    }
+  };
+}
+async function runEsbuild(entry) {
+  const esbuild = await loadEsbuild();
+  const opts = {
+    stdin: {
+      contents: entry,
+      resolveDir: vaultRepoRoot(),
+      loader: "ts",
+      sourcefile: "exec.ts"
+    },
+    plugins: [vaultResolver()],
+    bundle: true,
+    write: false,
+    format: "iife",
+    target: "es2020",
+    platform: "browser",
+    treeShaking: true,
+    minify: false,
+    logLevel: "silent"
+  };
+  try {
+    return await esbuild.build(opts);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("service is no longer running")) {
+      esbuild.stop();
+      return await esbuild.build(opts);
+    }
+    throw error;
+  }
+}
+function applyReturnInsert(bundled) {
+  const anchor = `${SENTINEL}.then(`;
+  const i = bundled.lastIndexOf(anchor);
+  return i === -1 ? bundled : bundled.slice(0, i) + "return " + bundled.slice(i);
+}
+function formatBuildErrors(errors) {
+  return errors.map((e) => {
+    const l = e.location;
+    const loc = l ? ` (${l.file}:${l.line}:${l.column})` : "";
+    return `${e.text}${loc}`;
+  }).join("\n");
+}
+async function bundleExec(code) {
+  preflightLibs(splitLeadingImports(code).imports);
+  const entry = buildEntry(code);
+  let result;
+  try {
+    result = await runEsbuild(entry);
+  } catch (error) {
+    const errs = error?.errors;
+    if (Array.isArray(errs) && errs.length > 0) {
+      throw new Error(formatBuildErrors(errs));
+    }
+    throw error;
+  }
+  if (!result.outputFiles || result.outputFiles.length === 0) {
+    throw new Error("esbuild produced no output");
+  }
+  return applyReturnInsert(result.outputFiles[0].text);
+}
+var fs8, path5, SENTINEL, IMPORT_STMT_RE, LIB_SPECIFIER_RE;
+var init_bundle = __esm({
+  "src/vault/bundle.ts"() {
+    fs8 = __toESM(require("fs"));
+    path5 = __toESM(require("path"));
+    init_paths();
+    SENTINEL = "__CAPTURE_RESULT";
+    IMPORT_STMT_RE = /^\s*(?:(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)\s*)*import\b(?!\s*\()[^'"`]*?(['"])(?:[^'"`\\]|\\.)*\1[^\n;]*;?/;
+    LIB_SPECIFIER_RE = /(['"])libs\/((?:[^'"\\]|\\.)*)\1/g;
+  }
+});
+
+// src/cdp/commands/exec.ts
+async function cmdExec(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      `Usage: capture exec <code> [--target <id>] [--record] [--file <path>] [--har <id>]
+
+Execute JavaScript in a browser tab. Supports await (wrapped in async IIFE).
+
+Examples:
+  capture exec "document.title" --target <id>
+  capture exec "await fetch('/api/data').then(r=>r.json())" --target <id>
+  capture exec "document.querySelector('.btn').click()" --target <id>
+  capture exec --file /tmp/scrape.js --target <id> --record
+
+Import vault libs (dev checkout only): static imports first, then your code.
+  capture exec "import {searchEmails} from 'libs/gmail'; const ctx = await getContext(); return await searchEmails({ ...ctx, query: 'invoice' })"`
+    );
+    process.exit(0);
+  }
+  let code;
+  if (parsed.file) {
+    code = fs9.readFileSync(parsed.file, "utf-8");
+  } else {
+    code = parsed.positional[0];
+    if (!code) {
+      console.error(
+        `ERROR: Missing code to execute.
+
+Usage: capture exec <code> [--target <id>] [--record] [--file <path>]
+
+Examples:
+  capture exec "document.title" --target <id>
+  capture exec "document.querySelector('.btn').click()" --target <id>
+  capture exec --file /tmp/scrape.js --target <id> --record`
+      );
+      process.exit(1);
+    }
+  }
+  let prebuilt;
+  if (hasImports(code)) {
+    try {
+      prebuilt = await bundleExec(code);
+    } catch (e) {
+      console.error(`ERROR: ${e.message}`);
+      process.exit(1);
+    }
+  }
+  await withConnection(
+    parsed,
+    async (client) => {
+      await client.send("Emulation.setFocusEmulationEnabled", { enabled: true });
+      let standaloneRecorder;
+      if (parsed.record) {
+        standaloneRecorder = new HARRecorder(client);
+        await standaloneRecorder.start();
+      }
+      const expression = prebuilt ? prebuilt : /\bawait\b/.test(code) ? `(async () => { ${code} })()` : code;
+      const evalResult = await client.send("Runtime.evaluate", {
+        expression,
+        awaitPromise: true,
+        returnByValue: true
+      });
+      if (standaloneRecorder) {
+        const har = await standaloneRecorder.finish();
+        writeHarAndPrintSummary(har, parsed.harOut);
       }
-      entries = [];
-      async start() {
-        await this.client.send("Runtime.enable");
-        this.client.on("Runtime.consoleAPICalled", (params) => {
-          const p = params;
-          const text = p.args.map(
-            (a) => a.value !== void 0 ? String(a.value) : a.description ?? ""
-          ).join(" ");
-          this.entries.push({
-            level: p.type,
-            text,
-            timestamp: p.timestamp
-          });
-        });
-        this.client.on("Runtime.exceptionThrown", (params) => {
-          const p = params;
-          this.entries.push({
-            level: "error",
-            text: p.exceptionDetails.exception?.description ?? p.exceptionDetails.text ?? "Unknown exception",
-            timestamp: p.timestamp,
-            source: p.exceptionDetails.url ? `${p.exceptionDetails.url}:${p.exceptionDetails.lineNumber}` : void 0
-          });
-        });
+      if (evalResult.exceptionDetails) {
+        console.error(
+          `ERROR: ${evalResult.exceptionDetails.exception?.description ?? "Unknown error"}`
+        );
+        process.exit(1);
       }
-      finish() {
-        return [...this.entries];
+      console.log(JSON.stringify(evalResult.result?.value));
+    },
+    { settle: 3e3 }
+  );
+  return;
+}
+var fs9;
+var init_exec = __esm({
+  "src/cdp/commands/exec.ts"() {
+    fs9 = __toESM(require("fs"));
+    init_connection();
+    init_har_recorder();
+    init_har_output();
+    init_bundle();
+  }
+});
+
+// src/interact.ts
+async function clickByName(client, name, role) {
+  await client.send("Accessibility.enable");
+  await client.send("DOM.enable");
+  const { nodes } = await client.send("Accessibility.getFullAXTree");
+  await client.send("Accessibility.disable");
+  const nameLower = name.toLowerCase();
+  const matches = nodes.filter((n) => {
+    if (!n.backendDOMNodeId) return false;
+    if (!n.name?.value) return false;
+    if (n.name.value.toLowerCase() !== nameLower) return false;
+    if (role && n.role?.value !== role) return false;
+    return true;
+  });
+  if (matches.length === 0) {
+    throw new Error(
+      `No element found with accessible name "${name}"${role ? ` and role "${role}"` : ""}. Run \`capture a11y --interactive\` to see available elements.`
+    );
+  }
+  if (matches.length > 1 && !role) {
+    const INPUT_ROLES = /* @__PURE__ */ new Set(["textbox", "searchbox", "combobox", "textarea", "spinbutton"]);
+    const inputMatches = matches.filter((n) => n.role?.value && INPUT_ROLES.has(n.role.value));
+    if (inputMatches.length === 1) {
+      matches.length = 0;
+      matches.push(inputMatches[0]);
+    } else {
+      const summary = matches.slice(0, 5).map((n) => `  ${n.role?.value} "${n.name?.value}"`).join("\n");
+      throw new Error(
+        `Multiple elements match "${name}" \u2014 disambiguate with --role:
+${summary}`
+      );
+    }
+  }
+  const match = matches[0];
+  const backendNodeId = match.backendDOMNodeId;
+  await client.send("DOM.scrollIntoViewIfNeeded", { backendNodeId });
+  const { model } = await client.send("DOM.getBoxModel", { backendNodeId });
+  const quad = model.content;
+  const x = (quad[0] + quad[2] + quad[4] + quad[6]) / 4;
+  const y = (quad[1] + quad[3] + quad[5] + quad[7]) / 4;
+  await client.send("Input.dispatchMouseEvent", {
+    type: "mousePressed",
+    x,
+    y,
+    button: "left",
+    clickCount: 1
+  });
+  await client.send("Input.dispatchMouseEvent", {
+    type: "mouseReleased",
+    x,
+    y,
+    button: "left",
+    clickCount: 1
+  });
+  return {
+    x: Math.round(x),
+    y: Math.round(y),
+    role: match.role?.value ?? "unknown",
+    name: match.name?.value ?? name
+  };
+}
+async function typeText(client, text) {
+  await client.send("Input.insertText", { text });
+}
+async function focusAndType(client, fieldName, text, role) {
+  const result = await clickByName(client, fieldName, role);
+  await new Promise((r) => setTimeout(r, 100));
+  await typeText(client, text);
+  return result;
+}
+var init_interact = __esm({
+  "src/interact.ts"() {
+  }
+});
+
+// src/cdp/commands/ui.ts
+async function cmdScreenshot(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      "Usage: capture screenshot [--target <id>] [--out <path>] [--viewport <preset>] [--height <px>] [--full-page]\n\nCapture a screenshot of the targeted tab. Saves to --out or auto-generates a path.\n\nOptions:\n  --viewport <preset>  Viewport preset (default: desktop)\n                       desktop-wide  1920x1080\n                       desktop       1280x800\n                       tablet        768x1024\n                       mobile        390x844\n  --height <px>        Override viewport height (e.g. 1600)\n  --full-page          Capture the entire scrollable page"
+    );
+    process.exit(0);
+  }
+  const VIEWPORTS = {
+    "desktop-wide": { width: 1920, height: 1080 },
+    "desktop": { width: 1280, height: 800 },
+    "tablet": { width: 768, height: 1024 },
+    "mobile": { width: 390, height: 844 }
+  };
+  const viewportName = parsed.viewport ?? "desktop";
+  const viewport = VIEWPORTS[viewportName];
+  if (!viewport) {
+    console.error(`Unknown viewport "${viewportName}". Options: ${Object.keys(VIEWPORTS).join(", ")}`);
+    process.exit(1);
+  }
+  if (parsed.height) {
+    viewport.height = parsed.height;
+  }
+  const result = await withConnection(
+    parsed,
+    async (client) => {
+      const png = await captureScreenshot(client, viewport, { fullPage: parsed.fullPage });
+      const outPath = parsed.out ? parsed.out : nextStepPath("screenshot", "manual") ?? `/tmp/capture-screenshot-${Date.now()}.png`;
+      fs10.writeFileSync(outPath, png);
+      return { path: outPath, bytes: png.length };
+    },
+    { settle: 0 }
+  );
+  console.log(JSON.stringify(result, null, 2));
+  return;
+}
+async function cmdClick(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      'Usage: capture click "name" [--role button|link|...] [--no-screenshot]\n\nClick an element by its accessible name. Auto-captures a screenshot after clicking.'
+    );
+    process.exit(0);
+  }
+  const name = parsed.positional[0];
+  if (!name) {
+    console.error('Usage: capture click "name" [--role button|link|...] [--no-screenshot]');
+    process.exit(1);
+  }
+  const clickSettle = parsed.settle !== void 0 ? parsed.settle : parsed.har ? 2500 : 1e3;
+  const result = await withConnection(
+    parsed,
+    async (client) => {
+      const clickResult = await clickByName(client, name, parsed.role);
+      const screenshot = await autoScreenshot(client, "click", name, parsed.noScreenshot);
+      return { ...clickResult, screenshot };
+    },
+    { settle: clickSettle }
+  );
+  console.log(JSON.stringify(result, null, 2));
+  return;
+}
+async function cmdType(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      'Usage: capture type "text" [--into "field name"] [--no-screenshot]\n\nType text into the focused element, or into a named field with --into.'
+    );
+    process.exit(0);
+  }
+  const text = parsed.positional[0];
+  if (!text) {
+    console.error('Usage: capture type "text" [--into "field name"] [--no-screenshot]');
+    process.exit(1);
+  }
+  const result = await withConnection(
+    parsed,
+    async (client) => {
+      let field = null;
+      if (parsed.into) {
+        await focusAndType(client, parsed.into, text, parsed.role);
+        field = parsed.into;
+      } else {
+        await typeText(client, text);
       }
-    };
-    INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
-      "button",
-      "link",
-      "textbox",
-      "searchbox",
-      "combobox",
-      "checkbox",
-      "radio",
-      "menuitem",
-      "tab",
-      "switch",
-      "slider",
-      "spinbutton",
-      "option",
-      "menuitemcheckbox",
-      "menuitemradio"
-    ]);
-    BROWSER_PATTERNS = {
-      "company.thebrowser.browser": ["arc"],
-      "com.google.chrome": ["chrome", "google chrome"],
-      "com.brave.browser": ["brave"],
-      "com.microsoft.edgemac": ["edge", "microsoft edge"],
-      "org.chromium.chromium": ["chromium"]
-    };
-    CDPClient = class {
-      ws;
-      messageId = 0;
-      pendingRequests = /* @__PURE__ */ new Map();
-      pendingTimeouts = /* @__PURE__ */ new Map();
-      eventHandlers = /* @__PURE__ */ new Map();
-      ready;
-      constructor(wsUrl, connectTimeout = 5e3) {
-        this.ws = new wrapper_default(wsUrl);
-        this.ready = new Promise((resolve2, reject) => {
-          const timeout = setTimeout(() => {
-            reject(new Error(`WebSocket connection timeout (${connectTimeout}ms)`));
-          }, connectTimeout);
-          this.ws.on("open", () => {
-            clearTimeout(timeout);
-            resolve2();
-          });
-          this.ws.on("error", (err) => {
-            clearTimeout(timeout);
-            reject(err);
-          });
-        });
-        this.ws.on("message", (data) => {
-          const msg = JSON.parse(data.toString());
-          if (msg.id !== void 0) {
-            const pending = this.pendingRequests.get(msg.id);
-            if (pending) {
-              this.pendingRequests.delete(msg.id);
-              const timer = this.pendingTimeouts.get(msg.id);
-              if (timer) {
-                clearTimeout(timer);
-                this.pendingTimeouts.delete(msg.id);
-              }
-              if (msg.error) {
-                pending.reject(new Error(msg.error.message));
-              } else {
-                pending.resolve(msg.result);
-              }
-            }
-          } else if (msg.method) {
-            const handlers = this.eventHandlers.get(msg.method);
-            handlers?.forEach((h) => h(msg.params));
-          }
-        });
+      const label = field ?? text;
+      const screenshot = await autoScreenshot(client, "type", label, parsed.noScreenshot);
+      return { typed: text, field, screenshot };
+    },
+    { settle: parsed.settle !== void 0 ? parsed.settle : parsed.har ? 1500 : 500 }
+  );
+  console.log(JSON.stringify(result, null, 2));
+  return;
+}
+async function cmdA11y(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      "Usage: capture a11y [--target <id>] [--json] [--interactive]\n\nGet the accessibility tree. Use --interactive for interactive elements only.\nUse --json for structured JSON output."
+    );
+    process.exit(0);
+  }
+  const result = await withConnection(
+    parsed,
+    async (client) => {
+      const tree = await getAccessibilityTree(client);
+      if (parsed.json) {
+        return tree;
       }
-      async waitReady() {
-        await this.ready;
+      const lines = flattenA11yTree(tree, {
+        interactive: parsed.interactive
+      });
+      return lines.join("\n");
+    },
+    { settle: 0 }
+  );
+  if (parsed.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(result);
+  }
+  if (!parsed.json) {
+    const lineCount = typeof result === "string" ? result.split("\n").filter(Boolean).length : 0;
+    if (lineCount === 0) {
+      console.error(
+        "\nNo elements found." + (parsed.interactive ? " Try without --interactive to see all nodes." : "") + '\n\nIf this page is part of your project, consider adding ARIA attributes:\n  - role="button|link|textbox" on interactive elements\n  - aria-label="..." on elements without visible text\n  - Semantic HTML (<button>, <input>, <nav>) provides roles automatically'
+      );
+    } else if (parsed.interactive && lineCount < 5) {
+      console.error(
+        `
+Only ${lineCount} interactive element${lineCount === 1 ? "" : "s"} found. If this seems low, the page may lack ARIA markup.
+Consider adding role and aria-label attributes to interactive elements in your frontend code.`
+      );
+    }
+  }
+  return;
+}
+var fs10;
+var init_ui = __esm({
+  "src/cdp/commands/ui.ts"() {
+    fs10 = __toESM(require("fs"));
+    init_connection();
+    init_screenshot();
+    init_a11y();
+    init_interact();
+    init_session_context();
+  }
+});
+
+// src/cdp/commands/traffic.ts
+async function cmdRecord(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      "Usage: capture record --target <id> [--duration <secs>] [--har-out <path>]\n\nPassive HAR recording for the specified duration (default: 10s)."
+    );
+    process.exit(0);
+  }
+  if (!parsed.target) {
+    console.error(
+      "Usage: capture record --target <id> [--duration <secs>] [--har-out <path>]"
+    );
+    process.exit(1);
+  }
+  const result = await recordTraffic({
+    port: parsed.port,
+    targetId: parsed.target,
+    duration: parsed.duration,
+    harOutPath: parsed.harOut
+  });
+  console.log(
+    JSON.stringify(
+      { entryCount: result.entryCount, harPath: result.harPath },
+      null,
+      2
+    )
+  );
+  return;
+}
+async function cmdNavigate(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      'Usage: capture navigate <url> [--har-out <path>] [--settle <ms>] [--har <id>]\n\nNavigate to URL and record HAR. Appends to session HAR if --har is set.\n\nExample: capture navigate "https://app.example.com/dashboard" --settle 3000'
+    );
+    process.exit(0);
+  }
+  const url = parsed.positional[0];
+  if (!url) {
+    console.error(
+      "Usage: capture navigate <url> [--har-out <path>] [--settle <ms>]"
+    );
+    process.exit(1);
+  }
+  const result = await navigateAndRecord({
+    port: parsed.port,
+    url,
+    targetId: parsed.target,
+    harOutPath: parsed.har ? void 0 : parsed.harOut,
+    settle: parsed.settle
+  });
+  if (parsed.har && result.har.log.entries.length > 0) {
+    appendToHarRecording(parsed.har, result.har.log.entries);
+    console.error(`  [har:${parsed.har}] +${result.har.log.entries.length} entries`);
+  }
+  console.log(
+    JSON.stringify(
+      {
+        entryCount: result.entryCount,
+        harPath: result.harPath,
+        tabUrl: result.tab.url,
+        timedOut: result.timedOut
+      },
+      null,
+      2
+    )
+  );
+  return;
+}
+async function cmdNetwork(parsed, _args) {
+  if (parsed.help) {
+    console.log(
+      'Usage: capture network <offline|online> [--target <id>]\n\nToggle network connectivity for a tab. Use "offline" to simulate\nnetwork failure (kills WebSocket connections, blocks HTTP requests).\nUse "online" to restore connectivity.'
+    );
+    process.exit(0);
+  }
+  const mode = parsed.positional[0];
+  if (!mode || !["offline", "online"].includes(mode)) {
+    console.error("Usage: capture network <offline|online> [--target <id>]");
+    process.exit(1);
+  }
+  const offline = mode === "offline";
+  const result = await withConnection(
+    parsed,
+    async (client) => {
+      await client.send("Network.enable");
+      await client.send("Network.emulateNetworkConditions", {
+        offline,
+        latency: offline ? -1 : 0,
+        downloadThroughput: offline ? 0 : -1,
+        uploadThroughput: offline ? 0 : -1
+      });
+      return { network: mode, offline };
+    },
+    { settle: 0 }
+  );
+  console.log(JSON.stringify(result, null, 2));
+  if (offline) {
+    console.error("\nNetwork disabled. WebSocket connections will drop.");
+    console.error("Restore with: capture network online");
+  } else {
+    console.error("\nNetwork restored.");
+  }
+  return;
+}
+var init_traffic = __esm({
+  "src/cdp/commands/traffic.ts"() {
+    init_record();
+    init_connection();
+    init_har_manager();
+  }
+});
+
+// src/cdp/commands/har.ts
+async function cmdHar(parsed, args) {
+  if (parsed.help) {
+    console.log(
+      "Usage: capture har <create|read|delete>\n\n  create                      Create a new HAR recording (returns id)\n  read [id]                   Read accumulated HAR entries (id optional in active session)\n  delete <id>                 Delete a HAR recording\n\nFilters (read):\n  --filter-url <pattern>      Substring or regex match on URL\n  --filter-status <code>      Status code, prefix (e.g. 4), or range (e.g. 400-499)\n  --filter-method <method>    HTTP method (GET, POST, ...)\n  --limit <N>                 Return only the first N matching entries\n\nPass --har <id> to exec/navigate commands to append traffic to a recording."
+    );
+    process.exit(0);
+  }
+  const subcommand = args[1];
+  if (subcommand === "create") {
+    const { id, path: harPath } = createHarRecording();
+    console.log(JSON.stringify({ id, path: harPath }, null, 2));
+    console.error(
+      `
+Pass --har ${id} to subsequent commands to record traffic.`
+    );
+    return;
+  }
+  if (subcommand === "read") {
+    let id = args[2];
+    if (id && id.startsWith("--")) id = void 0;
+    if (!id) {
+      const session = getActiveSession();
+      if (session?.harId) {
+        id = session.harId;
+      } else {
+        console.error("Usage: capture har read [id]\n  ID is optional when a capture session is active.");
+        process.exit(1);
       }
-      async send(method, params = {}, timeout = 6e4) {
-        await this.ready;
-        const id = ++this.messageId;
-        return new Promise((resolve2, reject) => {
-          this.pendingRequests.set(id, { resolve: resolve2, reject });
-          this.ws.send(JSON.stringify({ id, method, params }));
-          const timer = setTimeout(() => {
-            if (this.pendingRequests.has(id)) {
-              this.pendingRequests.delete(id);
-              this.pendingTimeouts.delete(id);
-              reject(new Error(`CDP request timeout (${timeout}ms): ${method}`));
-            }
-          }, timeout);
-          this.pendingTimeouts.set(id, timer);
-        });
+    }
+    const har = readHarRecording(id);
+    if (!har) {
+      console.error(`No HAR recording found for id: ${id}`);
+      process.exit(1);
+    }
+    let entries = har.log.entries;
+    const total = entries.length;
+    const filters = [];
+    if (parsed.filterUrl) {
+      const pattern = parsed.filterUrl;
+      let re = null;
+      try {
+        re = new RegExp(pattern, "i");
+      } catch {
+        re = null;
       }
-      on(event, handler) {
-        if (!this.eventHandlers.has(event)) {
-          this.eventHandlers.set(event, []);
+      entries = entries.filter(
+        (e) => re ? re.test(e.request.url) : e.request.url.toLowerCase().includes(pattern.toLowerCase())
+      );
+      filters.push(`url~${pattern}`);
+    }
+    if (parsed.filterStatus) {
+      const s = parsed.filterStatus;
+      let matcher;
+      if (/^\d+-\d+$/.test(s)) {
+        const [lo, hi] = s.split("-").map((n) => parseInt(n, 10));
+        matcher = (c) => c >= lo && c <= hi;
+      } else if (/^\d+$/.test(s)) {
+        if (s.length < 3) {
+          matcher = (c) => String(c).startsWith(s);
+        } else {
+          const n = parseInt(s, 10);
+          matcher = (c) => c === n;
         }
-        this.eventHandlers.get(event).push(handler);
+      } else {
+        matcher = () => true;
       }
-      close() {
-        for (const timer of this.pendingTimeouts.values()) {
-          clearTimeout(timer);
+      entries = entries.filter((e) => matcher(e.response.status));
+      filters.push(`status=${s}`);
+    }
+    if (parsed.filterMethod) {
+      const m = parsed.filterMethod;
+      entries = entries.filter((e) => e.request.method.toUpperCase() === m);
+      filters.push(`method=${m}`);
+    }
+    if (typeof parsed.limit === "number" && parsed.limit > 0) {
+      entries = entries.slice(0, parsed.limit);
+      filters.push(`limit=${parsed.limit}`);
+    }
+    const filtersLabel = filters.length > 0 ? `  [${filters.join(", ")}]` : "";
+    console.error(
+      `HAR: ${harFilePath(id)} (${entries.length}/${total} entries)${filtersLabel}`
+    );
+    console.log(JSON.stringify({ log: { entries } }, null, 2));
+    return;
+  }
+  if (subcommand === "delete") {
+    const id = args[2];
+    if (!id) {
+      console.error("Usage: capture har delete <id>");
+      process.exit(1);
+    }
+    deleteHarRecording(id);
+    console.log(JSON.stringify({ deleted: true, id }, null, 2));
+    return;
+  }
+  console.error(
+    "Usage: capture har <create|read|delete>\n  create              Create a new HAR recording (returns id)\n  read <id>           Read accumulated HAR entries\n  delete <id>         Delete a HAR recording"
+  );
+  process.exit(1);
+}
+var init_har = __esm({
+  "src/cdp/commands/har.ts"() {
+    init_har_manager();
+    init_session_context();
+  }
+});
+
+// src/vault/docs.ts
+function isAgentVisible(doc) {
+  return AGENT_VISIBLE_VISIBILITIES.has(doc.visibility);
+}
+function cacheDir() {
+  return path6.join(vaultRepoRoot(), ".cache", "docs");
+}
+function schemasPathFor(svc) {
+  return path6.join(vaultLibsDir(), svc, "schemas.ts");
+}
+function srcSha(svc) {
+  return (0, import_crypto.createHash)("sha256").update(fs11.readFileSync(schemasPathFor(svc), "utf8")).digest("hex");
+}
+function toJsonSchema(zodSchema) {
+  const s = zodSchema;
+  if (s?._zod?.def?.type === "void") {
+    const desc = s.description;
+    return desc ? { type: "null", description: desc } : { type: "null" };
+  }
+  if (!s?.toJSONSchema) {
+    throw new Error(
+      "Schema missing toJSONSchema method - ensure Zod 4+ is installed"
+    );
+  }
+  return s.toJSONSchema();
+}
+async function buildDoc(svc) {
+  const esbuild = await loadEsbuild();
+  const result = await esbuild.build({
+    entryPoints: [schemasPathFor(svc)],
+    bundle: true,
+    write: false,
+    format: "cjs",
+    platform: "node",
+    target: "es2020",
+    logLevel: "silent"
+  });
+  const text = result.outputFiles?.[0]?.text;
+  if (!text) throw new Error(`esbuild produced no output for ${svc}/schemas.ts`);
+  const mod = { exports: {} };
+  new Function("module", "exports", "require", text)(
+    mod,
+    mod.exports,
+    cjsRequire
+  );
+  const x = mod.exports;
+  const allSchemas = x.allSchemas ?? [];
+  const doc = {
+    library: `@vallum/${svc}`,
+    description: x.libraryDescription ?? `${svc} service library`,
+    visibility: x.libraryVisibility ?? "public",
+    functions: allSchemas.map((schema) => ({
+      name: schema.name,
+      description: schema.description,
+      ...schema.notes ? { notes: schema.notes } : {},
+      input: toJsonSchema(schema.input),
+      output: toJsonSchema(schema.output)
+    }))
+  };
+  if (x.libraryNotes) doc.notes = x.libraryNotes;
+  if (x.loginUrl) doc.loginUrl = x.loginUrl;
+  return doc;
+}
+async function getDoc(name) {
+  if (!isValidLibName(name) || !fs11.existsSync(schemasPathFor(name))) {
+    throw new Error(unknownLibMsg(name));
+  }
+  const sha = srcSha(name);
+  const cacheFile = path6.join(cacheDir(), `${name}.json`);
+  if (fs11.existsSync(cacheFile)) {
+    try {
+      const cached = JSON.parse(fs11.readFileSync(cacheFile, "utf8"));
+      if (cached._srcSha === sha) {
+        delete cached._srcSha;
+        return cached;
+      }
+    } catch {
+    }
+  }
+  const doc = await buildDoc(name);
+  fs11.mkdirSync(cacheDir(), { recursive: true });
+  fs11.writeFileSync(
+    cacheFile,
+    JSON.stringify({ ...doc, _srcSha: sha }, null, 2)
+  );
+  return doc;
+}
+async function listDocs() {
+  const out = [];
+  for (const name of listLibs()) {
+    let doc;
+    try {
+      doc = await getDoc(name);
+    } catch (e) {
+      console.error(
+        `WARN: skipping lib "${name}" \u2014 ${e.message}`
+      );
+      continue;
+    }
+    if (isAgentVisible(doc)) out.push(doc);
+  }
+  return out;
+}
+var fs11, path6, import_crypto, AGENT_VISIBLE_VISIBILITIES, cjsRequire;
+var init_docs = __esm({
+  "src/vault/docs.ts"() {
+    fs11 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
+    import_crypto = require("crypto");
+    init_paths();
+    AGENT_VISIBLE_VISIBILITIES = /* @__PURE__ */ new Set(["public", "chat"]);
+    cjsRequire = (id) => {
+      if (typeof require === "function") return require(id);
+      throw new Error(`cannot require('${id}') \u2014 unavailable in this runtime`);
+    };
+  }
+});
+
+// src/cdp/commands/lib.ts
+function scoreToken(token, service, fnName, fnDesc, serviceDesc) {
+  const q = token.toLowerCase();
+  const fn = fnName.toLowerCase();
+  const svc = service.toLowerCase();
+  const fnD = fnDesc.toLowerCase();
+  const svcD = serviceDesc.toLowerCase();
+  let score = 0;
+  let match = "";
+  if (fn === q) {
+    score += FUNCTION_NAME_EXACT;
+    match = "function-name (exact)";
+  } else if (fn.startsWith(q)) {
+    score += FUNCTION_NAME_PREFIX;
+    match = "function-name (prefix)";
+  } else if (fn.includes(q)) {
+    score += FUNCTION_NAME_SUBSTRING;
+    match = "function-name";
+  }
+  if (svc.includes(q)) {
+    score += SERVICE_NAME_MATCH;
+    if (!match) match = "service-name";
+  }
+  if (fnD.includes(q)) {
+    score += FUNCTION_DESC_SUBSTRING;
+    if (!match) match = "function-desc";
+  }
+  if (svcD.includes(q)) {
+    score += SERVICE_DESC_SUBSTRING;
+    if (!match) match = "service-desc";
+  }
+  return { score, match };
+}
+function scoreHit(query, service, fnName, fnDesc, serviceDesc) {
+  const tokens = query.split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return { score: 0, match: "" };
+  if (tokens.length === 1) {
+    return scoreToken(tokens[0], service, fnName, fnDesc, serviceDesc);
+  }
+  let total = 0;
+  let bestScore = -1;
+  let bestMatch = "";
+  for (const token of tokens) {
+    const r = scoreToken(token, service, fnName, fnDesc, serviceDesc);
+    if (r.score === 0) return { score: 0, match: "" };
+    total += r.score;
+    if (r.score > bestScore) {
+      bestScore = r.score;
+      bestMatch = r.match;
+    }
+  }
+  return { score: total, match: bestMatch };
+}
+function resolveName(query, names) {
+  if (names.includes(query)) return { name: query };
+  const lower = query.toLowerCase();
+  const prefix = names.filter((n) => n.toLowerCase().startsWith(lower));
+  if (prefix.length === 1) return { name: prefix[0] };
+  if (prefix.length > 1) {
+    return { error: `Ambiguous lib "${query}" \u2014 matches: ${prefix.join(", ")}` };
+  }
+  return { error: `Unknown lib "${query}". Available: ${names.join(", ")}` };
+}
+async function cmdLib(parsed, _args) {
+  if (parsed.help) {
+    console.log(USAGE);
+    process.exit(0);
+  }
+  const sub = parsed.positional[0];
+  if (sub === "list") {
+    const docs = await listDocs();
+    const rows = docs.map((d) => {
+      const name = svcName(d);
+      return {
+        name,
+        functionCount: d.functions.length,
+        description: d.description,
+        srcPath: srcPathFor(name)
+      };
+    });
+    console.log(JSON.stringify(rows, null, 2));
+    console.error(
+      `
+${rows.length} libs. Next: capture lib show <name>  \xB7  capture lib read <name> <fn>`
+    );
+    return;
+  }
+  if (sub === "search") {
+    const query = parsed.positional[1];
+    if (!query) {
+      console.error('Usage: capture lib search "<query>" [--limit N]');
+      process.exit(1);
+    }
+    const limit = Math.min(
+      typeof parsed.limit === "number" && parsed.limit > 0 ? parsed.limit : 20,
+      500
+    );
+    const docs = await listDocs();
+    const hits = [];
+    for (const d of docs) {
+      const service = svcName(d);
+      for (const fn of d.functions) {
+        const { score, match } = scoreHit(
+          query,
+          service,
+          fn.name,
+          fn.description ?? "",
+          d.description ?? ""
+        );
+        if (score > 0) {
+          hits.push({
+            service,
+            function: fn.name,
+            match,
+            score,
+            description: fn.description,
+            srcPath: srcPathFor(service)
+          });
         }
-        this.pendingTimeouts.clear();
-        this.ws.close();
       }
+    }
+    hits.sort((a, b) => b.score - a.score);
+    const top = hits.slice(0, limit);
+    console.log(JSON.stringify(top, null, 2));
+    console.error(
+      `
+${hits.length} hit(s)${hits.length > limit ? ` (showing ${limit})` : ""}. Next: capture lib read <service> <function>`
+    );
+    return;
+  }
+  if (sub === "show") {
+    const name = parsed.positional[1];
+    if (!name) {
+      console.error("Usage: capture lib show <name>");
+      process.exit(1);
+    }
+    const r = resolveName(name, listLibs());
+    if ("error" in r) {
+      console.error(r.error);
+      process.exit(1);
+    }
+    let doc;
+    try {
+      doc = await getDoc(r.name);
+    } catch (e) {
+      console.error(e.message);
+      process.exit(1);
+    }
+    if (!isAgentVisible(doc)) {
+      console.error(
+        `Unknown lib "${name}". Available: ${listLibs().join(", ")}`
+      );
+      process.exit(1);
+    }
+    const service = r.name;
+    const out = {
+      service,
+      description: doc.description,
+      ...doc.loginUrl ? { loginUrl: doc.loginUrl } : {},
+      ...doc.notes ? { notes: doc.notes } : {},
+      srcPath: srcPathFor(service),
+      functions: doc.functions.map((f) => ({
+        name: f.name,
+        description: f.description
+      }))
     };
-    LOCK_DIR = os2.tmpdir();
-    LOCK_STALE_MS = 12e4;
-    LOCK_TIMEOUT_MS = 6e4;
-    LOCK_POLL_BASE_MS = 200;
-    heldLocks = /* @__PURE__ */ new Set();
-    cleanupRegistered = false;
+    console.log(JSON.stringify(out, null, 2));
+    console.error(
+      `
+Schemas required before exec \u2014 capture lib read ${service} <fn>`
+    );
+    return;
+  }
+  if (sub === "read") {
+    const name = parsed.positional[1];
+    if (!name) {
+      console.error("Usage: capture lib read <name> [fn\u2026]");
+      process.exit(1);
+    }
+    const r = resolveName(name, listLibs());
+    if ("error" in r) {
+      console.error(r.error);
+      process.exit(1);
+    }
+    let doc;
+    try {
+      doc = await getDoc(r.name);
+    } catch (e) {
+      console.error(e.message);
+      process.exit(1);
+    }
+    const service = svcName(doc);
+    const fns = parsed.positional.slice(2);
+    if (fns.length === 0) {
+      const out2 = {
+        service,
+        description: doc.description,
+        ...doc.notes ? { notes: doc.notes } : {},
+        srcPath: srcPathFor(service),
+        functions: doc.functions.map((f) => ({
+          name: f.name,
+          description: f.description
+        }))
+      };
+      console.log(JSON.stringify(out2, null, 2));
+      console.error(
+        `
+Name functions to load schemas: capture lib read ${service} <fn> [fn\u2026]`
+      );
+      return;
+    }
+    const byName = new Map(doc.functions.map((f) => [f.name, f]));
+    const found = [];
+    const missing = [];
+    for (const op of fns) {
+      const fn = byName.get(op);
+      if (fn) found.push(fn);
+      else missing.push(op);
+    }
+    if (found.length === 0) {
+      const available = doc.functions.map((f) => f.name).join(", ");
+      const label = missing.length > 1 ? `Functions "${missing.join('", "')}"` : `Function "${missing[0]}"`;
+      console.error(`${label} not in ${service}. Available: ${available}`);
+      process.exit(1);
+    }
+    const out = {
+      service,
+      srcPath: srcPathFor(service),
+      functions: found.map((f) => ({
+        name: f.name,
+        description: f.description,
+        ...f.notes ? { notes: f.notes } : {},
+        input: f.input,
+        output: f.output
+      })),
+      ...missing.length > 0 ? { missing } : {}
+    };
+    console.log(JSON.stringify(out, null, 2));
+    const firstFn = found[0].name;
+    console.error(
+      `
+Run it: capture exec "import {${firstFn}} from 'libs/${service}'; return await ${firstFn}({\u2026})"`
+    );
+    return;
+  }
+  console.error(USAGE);
+  process.exit(1);
+}
+var path7, USAGE, FUNCTION_NAME_EXACT, FUNCTION_NAME_PREFIX, FUNCTION_NAME_SUBSTRING, SERVICE_NAME_MATCH, FUNCTION_DESC_SUBSTRING, SERVICE_DESC_SUBSTRING, svcName, srcPathFor;
+var init_lib = __esm({
+  "src/cdp/commands/lib.ts"() {
+    path7 = __toESM(require("path"));
+    init_paths();
+    init_docs();
+    USAGE = `Usage: capture lib <list|search|show|read> [options]
+
+  list                          List available libs (name, fn count, description, srcPath)
+  search "<query>" [--limit N]  Fuzzy-search functions across all libs (ranked)
+  show <name>                   Lib + function summaries (no schemas)
+  read <name> [fn\u2026]             Full input/output JSON schemas (+ .ts source path)
+
+Then run a lib in the active authenticated tab:
+  capture exec "import {<fn>} from 'libs/<name>'; return await <fn>({\u2026})"
+
+Dev-checkout-only feature (requires vault/ source + esbuild).`;
+    FUNCTION_NAME_EXACT = 100;
+    FUNCTION_NAME_PREFIX = 60;
+    FUNCTION_NAME_SUBSTRING = 40;
+    SERVICE_NAME_MATCH = 50;
+    FUNCTION_DESC_SUBSTRING = 20;
+    SERVICE_DESC_SUBSTRING = 10;
+    svcName = (doc) => doc.library.replace(/^@vallum\//, "");
+    srcPathFor = (name) => path7.join(vaultLibsDir(), name, "index.ts");
+  }
+});
+
+// src/cdp/dispatch.ts
+async function cdpMain2() {
+  const args = process.argv.slice(2);
+  const parsed = parseCliArgs(args);
+  switch (parsed.command) {
+    case "detect":
+      return cmdDetect(parsed, args);
+    case "list":
+      return cmdList(parsed, args);
+    case "open":
+      return cmdOpen(parsed, args);
+    case "reset-tab":
+      return cmdResetTab(parsed, args);
+    case "exec":
+      return cmdExec(parsed, args);
+    case "screenshot":
+      return cmdScreenshot(parsed, args);
+    case "click":
+      return cmdClick(parsed, args);
+    case "type":
+      return cmdType(parsed, args);
+    case "a11y":
+      return cmdA11y(parsed, args);
+    case "record":
+      return cmdRecord(parsed, args);
+    case "navigate":
+      return cmdNavigate(parsed, args);
+    case "network":
+      return cmdNetwork(parsed, args);
+    case "har":
+      return cmdHar(parsed, args);
+    case "lib":
+      return cmdLib(parsed, args);
+    default:
+      console.log(CDP_USAGE);
+  }
+}
+var init_dispatch = __esm({
+  "src/cdp/dispatch.ts"() {
+    init_args();
+    init_usage();
+    init_tabs();
+    init_exec();
+    init_ui();
+    init_traffic();
+    init_har();
+    init_lib();
+  }
+});
+
+// src/cdp.ts
+var cdp_exports = {};
+__export(cdp_exports, {
+  CDPClient: () => CDPClient,
+  ConsoleRecorder: () => ConsoleRecorder,
+  HARRecorder: () => HARRecorder,
+  acquireTabLock: () => acquireTabLock,
+  captureScreenshot: () => captureScreenshot,
+  cdpMain: () => cdpMain2,
+  detectCdpPort: () => detectCdpPort,
+  executeInBrowser: () => executeInBrowser,
+  findTab: () => findTab,
+  findTabById: () => findTabById,
+  getAccessibilityTree: () => getAccessibilityTree,
+  isTabLocked: () => isTabLocked,
+  listTargets: () => listTargets,
+  navigateAndRecord: () => navigateAndRecord,
+  navigateAndWait: () => navigateAndWait,
+  openTab: () => openTab,
+  recordTraffic: () => recordTraffic,
+  releaseTabLock: () => releaseTabLock,
+  withTabLock: () => withTabLock
+});
+var isMainModule;
+var init_cdp = __esm({
+  "src/cdp.ts"() {
+    init_client();
+    init_detect();
+    init_targets();
+    init_screenshot();
+    init_a11y();
+    init_execute();
+    init_record();
+    init_har_recorder();
+    init_console_recorder();
+    init_tab_lock();
+    init_dispatch();
     isMainModule = process.argv[1]?.endsWith("cdp.ts") || process.argv[1]?.endsWith("cdp.mjs");
     if (isMainModule) {
-      main().then(() => {
+      cdpMain().then(() => {
         if (process.stdout.writableNeedDrain) {
           process.stdout.once("drain", () => process.exit(0));
         } else {
@@ -5551,26 +6352,30 @@ var init_cdp = __esm({
 });
 
 // src/capture.ts
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+init_cdp();
+
+// src/session/commands.ts
+var fs12 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 var import_child_process2 = require("child_process");
 init_har_manager();
-init_cdp();
 init_session_context();
-var CAPTURE_ROOT2 = path4.join(os3.tmpdir(), "capture-sessions");
+var CAPTURE_ROOT2 = path8.join(os3.tmpdir(), "capture-sessions");
 function sessionDir(id) {
-  return path4.join(CAPTURE_ROOT2, id);
+  return path8.join(CAPTURE_ROOT2, id);
 }
 function sessionMetaPath(id) {
-  return path4.join(sessionDir(id), ".session.json");
+  return path8.join(sessionDir(id), ".session.json");
 }
 function readSession(id) {
   const metaPath = sessionMetaPath(id);
-  if (!fs4.existsSync(metaPath)) {
+  if (!fs12.existsSync(metaPath)) {
     throw new Error(`No capture session found: ${id}`);
   }
-  return JSON.parse(fs4.readFileSync(metaPath, "utf-8"));
+  return JSON.parse(fs12.readFileSync(metaPath, "utf-8"));
 }
 function generateId() {
   return `cap-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
@@ -5584,8 +6389,8 @@ async function start(args) {
   }
   const id = generateId();
   const dir = sessionDir(id);
-  fs4.mkdirSync(path4.join(dir, "shots"), { recursive: true });
-  fs4.mkdirSync(path4.join(dir, "a11y"), { recursive: true });
+  fs12.mkdirSync(path8.join(dir, "shots"), { recursive: true });
+  fs12.mkdirSync(path8.join(dir, "a11y"), { recursive: true });
   let harId = null;
   try {
     const harResult = createHarRecording();
@@ -5614,7 +6419,7 @@ async function start(args) {
     stepCount: 0,
     logPids: []
   };
-  fs4.writeFileSync(sessionMetaPath(id), JSON.stringify(session, null, 2));
+  fs12.writeFileSync(sessionMetaPath(id), JSON.stringify(session, null, 2));
   setActiveSession({
     sessionId: id,
     dir,
@@ -5627,8 +6432,8 @@ async function start(args) {
     bundleDir: dir,
     harId,
     targetId,
-    shotsDir: path4.join(dir, "shots"),
-    a11yDir: path4.join(dir, "a11y")
+    shotsDir: path8.join(dir, "shots"),
+    a11yDir: path8.join(dir, "a11y")
   };
   console.log(JSON.stringify(result, null, 2));
   console.error(`
@@ -5645,8 +6450,8 @@ function logCommand(args) {
     console.error("Usage: capture log <path> [--name label] [--session <id>]");
     process.exit(1);
   }
-  const resolved = path4.resolve(sourcePath);
-  if (!fs4.existsSync(resolved)) {
+  const resolved = path8.resolve(sourcePath);
+  if (!fs12.existsSync(resolved)) {
     throw new Error(`Log file not found: ${resolved}`);
   }
   let name = null;
@@ -5663,21 +6468,21 @@ function logCommand(args) {
     sessionId = active.sessionId;
   }
   const session = readSession(sessionId);
-  name = name ?? path4.basename(resolved, path4.extname(resolved));
-  const logsDir = path4.join(session.dir, "logs");
-  fs4.mkdirSync(logsDir, { recursive: true });
-  const destPath = path4.join(logsDir, `${name}.log`);
-  const outFd = fs4.openSync(destPath, "a");
+  name = name ?? path8.basename(resolved, path8.extname(resolved));
+  const logsDir = path8.join(session.dir, "logs");
+  fs12.mkdirSync(logsDir, { recursive: true });
+  const destPath = path8.join(logsDir, `${name}.log`);
+  const outFd = fs12.openSync(destPath, "a");
   const child = (0, import_child_process2.spawn)(
     "sh",
     ["-c", `tail -f "${resolved}" | perl -MPOSIX -ne 'print strftime("%Y-%m-%dT%H:%M:%SZ",gmtime())." ".$_'`],
     { detached: true, stdio: ["ignore", outFd, "ignore"] }
   );
   child.unref();
-  fs4.closeSync(outFd);
+  fs12.closeSync(outFd);
   const pid = child.pid;
   session.logPids.push({ pid, name, sourcePath: resolved });
-  fs4.writeFileSync(sessionMetaPath(session.id), JSON.stringify(session, null, 2));
+  fs12.writeFileSync(sessionMetaPath(session.id), JSON.stringify(session, null, 2));
   console.log(JSON.stringify({ name, sourcePath: resolved, destPath, pid }, null, 2));
 }
 async function stop(args) {
@@ -5699,17 +6504,17 @@ async function stop(args) {
   if (session.logPids?.length) {
     await new Promise((r) => setTimeout(r, 200));
   }
-  const shotsDir = path4.join(session.dir, "shots");
-  const screenshots = fs4.existsSync(shotsDir) ? fs4.readdirSync(shotsDir).filter((f) => f.endsWith(".png") || f.endsWith(".jpg")).map((f) => ({ name: f, path: path4.join(shotsDir, f) })) : [];
-  const a11yDir = path4.join(session.dir, "a11y");
-  const a11y = fs4.existsSync(a11yDir) ? fs4.readdirSync(a11yDir).filter((f) => f.endsWith(".json") || f.endsWith(".txt")).map((f) => ({ name: f, path: path4.join(a11yDir, f) })) : [];
+  const shotsDir = path8.join(session.dir, "shots");
+  const screenshots = fs12.existsSync(shotsDir) ? fs12.readdirSync(shotsDir).filter((f) => f.endsWith(".png") || f.endsWith(".jpg")).map((f) => ({ name: f, path: path8.join(shotsDir, f) })) : [];
+  const a11yDir = path8.join(session.dir, "a11y");
+  const a11y = fs12.existsSync(a11yDir) ? fs12.readdirSync(a11yDir).filter((f) => f.endsWith(".json") || f.endsWith(".txt")).map((f) => ({ name: f, path: path8.join(a11yDir, f) })) : [];
   let har = null;
   if (session.harId) {
     try {
       const harData = readHarRecording(session.harId);
       if (harData) {
-        const harPath = path4.join(session.dir, "har.json");
-        fs4.writeFileSync(harPath, JSON.stringify(harData, null, 2));
+        const harPath = path8.join(session.dir, "har.json");
+        fs12.writeFileSync(harPath, JSON.stringify(harData, null, 2));
         har = { id: session.harId, path: harPath, entryCount: harData.log.entries.length };
         try {
           deleteHarRecording(session.harId);
@@ -5720,16 +6525,16 @@ async function stop(args) {
       console.error(`Warning: could not read HAR: ${err instanceof Error ? err.message : err}`);
     }
   }
-  const logsDir = path4.join(session.dir, "logs");
-  const logs = fs4.existsSync(logsDir) ? fs4.readdirSync(logsDir).filter((f) => f.endsWith(".log")).map((f) => {
-    const filePath = path4.join(logsDir, f);
-    const content = fs4.readFileSync(filePath, "utf-8");
+  const logsDir = path8.join(session.dir, "logs");
+  const logs = fs12.existsSync(logsDir) ? fs12.readdirSync(logsDir).filter((f) => f.endsWith(".log")).map((f) => {
+    const filePath = path8.join(logsDir, f);
+    const content = fs12.readFileSync(filePath, "utf-8");
     const lines = content ? content.split("\n").filter(Boolean).length : 0;
     return { name: f, path: filePath, lines };
   }) : [];
   const knownDirs = /* @__PURE__ */ new Set(["shots", "a11y", "logs"]);
   const knownFiles = /* @__PURE__ */ new Set([".session.json", "har.json", "bundle.json"]);
-  const other = fs4.readdirSync(session.dir).filter((f) => !knownDirs.has(f) && !knownFiles.has(f)).map((f) => ({ name: f, path: path4.join(session.dir, f) }));
+  const other = fs12.readdirSync(session.dir).filter((f) => !knownDirs.has(f) && !knownFiles.has(f)).map((f) => ({ name: f, path: path8.join(session.dir, f) }));
   clearActiveSession();
   const manifest = {
     id: session.id,
@@ -5743,8 +6548,8 @@ async function stop(args) {
     logs,
     other
   };
-  const bundlePath = path4.join(session.dir, "bundle.json");
-  fs4.writeFileSync(bundlePath, JSON.stringify(manifest, null, 2));
+  const bundlePath = path8.join(session.dir, "bundle.json");
+  fs12.writeFileSync(bundlePath, JSON.stringify(manifest, null, 2));
   console.log(JSON.stringify({
     bundlePath,
     summary: {
@@ -5761,13 +6566,13 @@ Bundle written: ${bundlePath}`);
   console.error(`Read it: capture session view ${id}`);
 }
 function list() {
-  if (!fs4.existsSync(CAPTURE_ROOT2)) {
+  if (!fs12.existsSync(CAPTURE_ROOT2)) {
     console.log("[]");
     return;
   }
-  const sessions = fs4.readdirSync(CAPTURE_ROOT2).filter((d) => fs4.existsSync(sessionMetaPath(d))).map((d) => {
+  const sessions = fs12.readdirSync(CAPTURE_ROOT2).filter((d) => fs12.existsSync(sessionMetaPath(d))).map((d) => {
     const session = readSession(d);
-    const hasBundled = fs4.existsSync(path4.join(session.dir, "bundle.json"));
+    const hasBundled = fs12.existsSync(path8.join(session.dir, "bundle.json"));
     return { id: session.id, startedAt: session.startedAt, url: session.url, status: hasBundled ? "stopped" : "active" };
   });
   console.log(JSON.stringify(sessions, null, 2));
@@ -5779,12 +6584,12 @@ function view(args) {
     process.exit(1);
   }
   const session = readSession(id);
-  const bundlePath = path4.join(session.dir, "bundle.json");
-  if (!fs4.existsSync(bundlePath)) {
+  const bundlePath = path8.join(session.dir, "bundle.json");
+  if (!fs12.existsSync(bundlePath)) {
     console.error(`Session ${id} hasn't been stopped yet. Run: capture session stop ${id}`);
     process.exit(1);
   }
-  const manifest = JSON.parse(fs4.readFileSync(bundlePath, "utf-8"));
+  const manifest = JSON.parse(fs12.readFileSync(bundlePath, "utf-8"));
   const filter = args.find((_, i) => args[i - 1] === "--filter");
   if (filter) {
     const section = manifest[filter];
@@ -5832,17 +6637,19 @@ Related:  capture log <path> [--name label]   Tail a log into the active session
 See also: capture --help                      Full command list`);
   }
 }
-async function main2() {
+
+// src/capture.ts
+async function main() {
   const [command, ...args] = process.argv.slice(2);
   if (command === "--version" || command === "-v" || command === "version") {
-    const declared = "1.3.3";
+    const declared = "1.3.5";
     if (declared) {
       console.log(declared);
       return;
     }
     try {
-      const pkgPath = path4.resolve(__dirname, "..", "package.json");
-      const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path9.resolve(__dirname, "..", "package.json");
+      const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
       console.log(pkg.version);
     } catch {
       console.log("unknown");
@@ -5866,9 +6673,10 @@ async function main2() {
     case "record":
     case "navigate":
     case "har":
+    case "lib":
     case "network":
     case "list":
-      return main();
+      return cdpMain2();
     default:
       console.log(`Capture \u2014 browser automation over CDP for validating UI features.
 
@@ -5921,6 +6729,14 @@ DIAGNOSTICS & ONE-OFFS (no session needed)
   network <offline|online>                 Toggle connectivity for a tab
   har create | read [id] | delete <id>     Manage standalone HAR recordings
 
+LIBRARY (vault libs \u2014 dev checkout only)
+
+  lib list                                 List available libs
+  lib search "<query>" [--limit N]          Fuzzy-search functions across libs
+  lib show <name>                          Lib + function summaries
+  lib read <name> [fn\u2026]                    Full input/output schemas (+ .ts source path)
+  exec "import {fn} from 'libs/<name>'; return await fn({\u2026})"   Run a lib in the active tab
+
 TARGETING (only when NOT in a session, or picking a parallel tab)
 
   --target <tabId>   Exact id; a prefix of 8 chars is enough (preferred, parallel-safe)
@@ -5939,7 +6755,7 @@ PREREQ \u2014 a browser with CDP must be running:
   Verify with:        capture detect`);
   }
 }
-main2().catch((err) => {
+main().catch((err) => {
   console.error(err.message);
   process.exit(1);
 });