@btraut/browser-bridge 0.3.0 → 0.4.2

package/dist/api.js

@@ -138,7 +138,8 @@ var SessionRegistry = class {
       id,
       state: "INIT" /* INIT */,
       createdAt: now,
-      updatedAt: now
+      updatedAt: now,
+      lastAccessedAt: now
     };
     this.sessions.set(id, session);
     return session;
@@ -157,8 +158,23 @@ var SessionRegistry = class {
         `Session ${sessionId} does not exist.`
       );
     }
+    session.lastAccessedAt = /* @__PURE__ */ new Date();
     return session;
   }
+  cleanupIdleSessions(ttlMs, now = /* @__PURE__ */ new Date()) {
+    if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+      return 0;
+    }
+    let removed = 0;
+    for (const [id, session] of this.sessions.entries()) {
+      const idleMs = now.getTime() - session.lastAccessedAt.getTime();
+      if (idleMs > ttlMs) {
+        this.sessions.delete(id);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
   apply(sessionId, event) {
     const session = this.require(sessionId);
     if (session.state === "CLOSED" /* CLOSED */ && event !== "CLOSE") {
@@ -467,7 +483,18 @@ var createSessionRouter = (registry, options = {}) => {
   return router;
 };
 
-// packages/core/src/inspect.ts
+// packages/core/src/inspect/errors.ts
+var InspectError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "InspectError";
+    this.code = code;
+    this.retryable = options.retryable ?? false;
+    this.details = options.details;
+  }
+};
+
+// packages/core/src/inspect/service.ts
 var import_crypto3 = require("crypto");
 var import_promises2 = require("node:fs/promises");
 var import_node_path2 = __toESM(require("node:path"));
@@ -506,6 +533,7 @@ var ExtensionBridge = class {
     this.pending = /* @__PURE__ */ new Map();
     this.connected = false;
     this.tabs = [];
+    this.badMessageLogsRemaining = 3;
     this.heartbeatInterval = null;
     this.awaitingHeartbeat = false;
     this.debuggerListeners = /* @__PURE__ */ new Set();
@@ -636,7 +664,11 @@ var ExtensionBridge = class {
     if (this.socket && this.socket.readyState === import_ws.WebSocket.OPEN) {
       try {
         this.socket.terminate();
-      } catch {
+      } catch (error) {
+        console.debug(
+          "Extension socket terminate failed; falling back to close().",
+          error
+        );
         this.socket.close();
       }
     }
@@ -688,7 +720,11 @@ var ExtensionBridge = class {
     let message = null;
     try {
       message = JSON.parse(text);
-    } catch {
+    } catch (error) {
+      if (this.badMessageLogsRemaining > 0) {
+        this.badMessageLogsRemaining -= 1;
+        console.debug("Failed to parse extension message.", error);
+      }
       return;
     }
     if (!message || typeof message !== "object") {
@@ -920,227 +956,7 @@ var DriveController = class {
   }
 };
 
-// packages/core/src/page-state-script.ts
-var PAGE_STATE_SCRIPT = [
-  "(() => {",
-  "  const escape = (value) => {",
-  "    if (typeof CSS !== 'undefined' && typeof CSS.escape === 'function') {",
-  "      return CSS.escape(value);",
-  "    }",
-  `    return String(value).replace(/["'\\\\]/g, '\\\\$&');`,
-  "  };",
-  "  const truncate = (value, max) => {",
-  "    const text = String(value ?? '');",
-  "    return text.length > max ? text.slice(0, max) : text;",
-  "  };",
-  "  const selectorFor = (element) => {",
-  "    if (element.id) {",
-  "      return `#${escape(element.id)}`;",
-  "    }",
-  "    const name = element.getAttribute('name');",
-  "    if (name) {",
-  '      return `${element.tagName.toLowerCase()}[name="${escape(name)}"]`;',
-  "    }",
-  "    const parts = [];",
-  "    let node = element;",
-  "    while (node && node.nodeType === 1 && parts.length < 4) {",
-  "      let part = node.tagName.toLowerCase();",
-  "      const parent = node.parentElement;",
-  "      if (parent) {",
-  "        const siblings = Array.from(parent.children).filter(",
-  "          (child) => child.tagName === node.tagName",
-  "        );",
-  "        if (siblings.length > 1) {",
-  "          part += `:nth-of-type(${siblings.indexOf(node) + 1})`;",
-  "        }",
-  "      }",
-  "      parts.unshift(part);",
-  "      node = parent;",
-  "    }",
-  "    return parts.join('>');",
-  "  };",
-  "  const readStorage = (storage, limit) => {",
-  "    try {",
-  "      return Object.keys(storage)",
-  "        .slice(0, limit)",
-  "        .map((key) => ({",
-  "          key,",
-  "          value: truncate(storage.getItem(key), 500),",
-  "        }));",
-  "    } catch {",
-  "      return [];",
-  "    }",
-  "  };",
-  "  const forms = Array.from(document.querySelectorAll('form')).map((form) => {",
-  "    const fields = Array.from(form.elements)",
-  "      .filter((element) => element && element.tagName)",
-  "      .map((element) => {",
-  "        const tag = element.tagName.toLowerCase();",
-  "        const type = 'type' in element && element.type ? element.type : tag;",
-  "        const name = element.name || element.getAttribute('name') || element.id || '';",
-  "        let value = '';",
-  "        let options;",
-  "        if (tag === 'select') {",
-  "          const select = element;",
-  "          value = select.value ?? '';",
-  "          options = Array.from(select.options).map((option) => option.text);",
-  "        } else if (tag === 'input' && element.type === 'password') {",
-  "          value = '[redacted]';",
-  "        } else if (tag === 'input' || tag === 'textarea') {",
-  "          value = element.value ?? '';",
-  "        } else if (element.isContentEditable) {",
-  "          value = element.textContent ?? '';",
-  "        } else if ('value' in element) {",
-  "          value = element.value ?? '';",
-  "        }",
-  "        return {",
-  "          name,",
-  "          type,",
-  "          value: truncate(value, 500),",
-  "          ...(options ? { options } : {}),",
-  "        };",
-  "      });",
-  "    return {",
-  "      selector: selectorFor(form),",
-  "      action: form.getAttribute('action') || undefined,",
-  "      method: form.getAttribute('method') || undefined,",
-  "      fields,",
-  "    };",
-  "  });",
-  "  const localStorage = readStorage(window.localStorage, 100);",
-  "  const sessionStorage = readStorage(window.sessionStorage, 100);",
-  "  const cookies = (document.cookie ? document.cookie.split(';') : [])",
-  "    .map((entry) => entry.trim())",
-  "    .filter((entry) => entry.length > 0)",
-  "    .slice(0, 50)",
-  "    .map((entry) => {",
-  "      const [key, ...rest] = entry.split('=');",
-  "      return { key, value: truncate(rest.join('='), 500) };",
-  "    });",
-  "  return { forms, localStorage, sessionStorage, cookies };",
-  "})()"
-].join("\n");
-
-// packages/core/src/target-matching.ts
-var normalizeText = (value) => (value ?? "").trim().toLowerCase();
-var normalizeUrl = (value) => {
-  const normalized = normalizeText(value);
-  if (!normalized) {
-    return "";
-  }
-  const hashIndex = normalized.indexOf("#");
-  const withoutHash = hashIndex >= 0 ? normalized.slice(0, hashIndex) : normalized;
-  return withoutHash.endsWith("/") && withoutHash.length > 1 ? withoutHash.slice(0, -1) : withoutHash;
-};
-var scoreUrlMatch = (candidateUrl, hintUrl) => {
-  if (!candidateUrl || !hintUrl) {
-    return 0;
-  }
-  if (candidateUrl === hintUrl) {
-    return 100;
-  }
-  if (candidateUrl.includes(hintUrl) || hintUrl.includes(candidateUrl)) {
-    return 60;
-  }
-  return 0;
-};
-var scoreTitleMatch = (candidateTitle, hintTitle) => {
-  if (!candidateTitle || !hintTitle) {
-    return 0;
-  }
-  if (candidateTitle === hintTitle) {
-    return 80;
-  }
-  if (candidateTitle.includes(hintTitle) || hintTitle.includes(candidateTitle)) {
-    return 40;
-  }
-  return 0;
-};
-var scoreRecency = (lastSeenAt, now) => {
-  if (!lastSeenAt) {
-    return 0;
-  }
-  const ageMinutes = Math.max(0, (now - lastSeenAt) / 6e4);
-  return Math.max(0, 30 - ageMinutes);
-};
-var scoreHintRecency = (lastSeenAt, hintLastActiveAt) => {
-  if (!lastSeenAt || !hintLastActiveAt) {
-    return 0;
-  }
-  const deltaMinutes = Math.abs(lastSeenAt - hintLastActiveAt) / 6e4;
-  return Math.max(0, 20 - deltaMinutes);
-};
-var isBlankUrl = (url) => url.length === 0 || url === "about:blank";
-var rankTargetCandidates = (candidates, hint, now = Date.now()) => {
-  const normalizedHintUrl = normalizeUrl(hint?.url);
-  const normalizedHintTitle = normalizeText(hint?.title);
-  const hintLastActiveAt = hint?.lastActiveAt ? Date.parse(hint.lastActiveAt) : void 0;
-  const ranked = candidates.map((candidate) => {
-    const reasons = [];
-    const normalizedUrl = normalizeUrl(candidate.url);
-    const normalizedTitle = normalizeText(candidate.title);
-    let score = 0;
-    const urlScore = scoreUrlMatch(normalizedUrl, normalizedHintUrl);
-    if (urlScore > 0) {
-      score += urlScore;
-      reasons.push(urlScore >= 100 ? "url:exact" : "url:partial");
-    }
-    const titleScore = scoreTitleMatch(normalizedTitle, normalizedHintTitle);
-    if (titleScore > 0) {
-      score += titleScore;
-      reasons.push(titleScore >= 80 ? "title:exact" : "title:partial");
-    }
-    const recencyScore = scoreRecency(candidate.lastSeenAt, now);
-    if (recencyScore > 0) {
-      score += recencyScore;
-      reasons.push("recency");
-    }
-    const hintRecencyScore = scoreHintRecency(
-      candidate.lastSeenAt,
-      Number.isFinite(hintLastActiveAt) ? hintLastActiveAt : void 0
-    );
-    if (hintRecencyScore > 0) {
-      score += hintRecencyScore;
-      reasons.push("hint-recency");
-    }
-    if (isBlankUrl(normalizedUrl)) {
-      score -= 50;
-      reasons.push("blank-url");
-    }
-    return { candidate, score, reasons };
-  });
-  return ranked.sort((a, b) => {
-    if (a.score !== b.score) {
-      return b.score - a.score;
-    }
-    const aSeen = a.candidate.lastSeenAt ?? 0;
-    const bSeen = b.candidate.lastSeenAt ?? 0;
-    if (aSeen !== bSeen) {
-      return bSeen - aSeen;
-    }
-    return a.candidate.url.localeCompare(b.candidate.url);
-  });
-};
-var pickBestTarget = (candidates, hint, now = Date.now()) => {
-  const ranked = rankTargetCandidates(candidates, hint, now);
-  return ranked.length > 0 ? ranked[0] : null;
-};
-
-// packages/core/src/inspect.ts
-var InspectError = class extends Error {
-  constructor(code, message, options = {}) {
-    super(message);
-    this.name = "InspectError";
-    this.code = code;
-    this.retryable = options.retryable ?? false;
-    this.details = options.details;
-  }
-};
-var DEFAULT_MAX_SNAPSHOTS_PER_SESSION = 20;
-var DEFAULT_MAX_SNAPSHOT_HISTORY = 100;
-var SNAPSHOT_REF_ATTRIBUTE = "data-bv-ref";
-var MAX_REF_ASSIGNMENTS = 500;
-var MAX_REF_WARNINGS = 5;
+// packages/core/src/inspect/ax-snapshot.ts
 var INTERACTIVE_AX_ROLES = /* @__PURE__ */ new Set([
   "button",
   "link",
@@ -1167,24 +983,1080 @@ var LABEL_AX_ROLES = /* @__PURE__ */ new Set([
   "spinbutton",
   "slider"
 ]);
-var InspectService = class {
-  constructor(options) {
-    this.snapshotHistory = [];
-    this.registry = options.registry;
-    this.debugger = options.debuggerBridge;
-    this.extensionBridge = options.extensionBridge;
-    this.maxSnapshotsPerSession = options.maxSnapshotsPerSession ?? DEFAULT_MAX_SNAPSHOTS_PER_SESSION;
-    this.maxSnapshotHistory = options.maxSnapshotHistory ?? DEFAULT_MAX_SNAPSHOT_HISTORY;
+var getAxNodes = (snapshot) => {
+  const nodes = Array.isArray(snapshot) ? snapshot : snapshot?.nodes;
+  return Array.isArray(nodes) ? nodes : [];
+};
+var replaceAxNodes = (snapshot, nodes) => {
+  if (Array.isArray(snapshot)) {
+    return nodes;
   }
-  isConnected() {
-    return this.debugger?.hasAttachments() ?? false;
+  if (snapshot && typeof snapshot === "object") {
+    snapshot.nodes = nodes;
   }
-  getLastError() {
-    if (!this.lastError || !this.lastErrorAt) {
-      const debuggerError = this.debugger?.getLastError();
-      if (!debuggerError) {
-        return void 0;
-      }
+  return snapshot;
+};
+var getAxRole = (node) => {
+  const role = typeof node.role === "string" ? node.role : node.role?.value ?? "";
+  return typeof role === "string" ? role.toLowerCase() : "";
+};
+var getAxName = (node) => {
+  const name = typeof node.name === "string" ? node.name : node.name?.value ?? "";
+  return typeof name === "string" ? name : "";
+};
+var hasAxValue = (node) => {
+  if (!Array.isArray(node.properties)) {
+    return false;
+  }
+  for (const prop of node.properties) {
+    if (!prop || typeof prop !== "object") {
+      continue;
+    }
+    const value = prop.value?.value;
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (typeof value === "string" && value.trim().length === 0) {
+      continue;
+    }
+    return true;
+  }
+  return false;
+};
+var normalizeQuery = (value) => value.trim().toLowerCase();
+var matchesTextValue = (value, query) => {
+  if (!query) {
+    return false;
+  }
+  return value.toLowerCase().includes(query);
+};
+var matchesAxText = (node, query) => {
+  if (!query) {
+    return false;
+  }
+  const candidates = [getAxName(node)];
+  if (Array.isArray(node.properties)) {
+    for (const prop of node.properties) {
+      if (!prop || typeof prop !== "object") {
+        continue;
+      }
+      const value = prop.value?.value;
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (typeof value === "string") {
+        candidates.push(value);
+      } else if (typeof value === "number" || typeof value === "boolean") {
+        candidates.push(String(value));
+      }
+    }
+  }
+  return candidates.some((text) => matchesTextValue(text, query));
+};
+var isInteractiveAxNode = (node) => {
+  const role = getAxRole(node);
+  return Boolean(role && INTERACTIVE_AX_ROLES.has(role));
+};
+var filterAxSnapshot = (snapshot, predicate) => {
+  const nodes = getAxNodes(snapshot);
+  if (nodes.length === 0) {
+    return snapshot;
+  }
+  const keepIds = /* @__PURE__ */ new Set();
+  const filtered = nodes.filter((node) => {
+    if (!node || typeof node !== "object") {
+      return false;
+    }
+    const keep = predicate(node);
+    if (keep && typeof node.nodeId === "string") {
+      keepIds.add(node.nodeId);
+    }
+    return keep;
+  });
+  for (const node of filtered) {
+    if (Array.isArray(node.childIds)) {
+      node.childIds = node.childIds.filter((id) => keepIds.has(id));
+    }
+  }
+  return replaceAxNodes(snapshot, filtered);
+};
+var collectKeptDescendants = (nodeId, nodeById, keepIds, visited = /* @__PURE__ */ new Set()) => {
+  if (visited.has(nodeId)) {
+    return [];
+  }
+  visited.add(nodeId);
+  if (keepIds.has(nodeId)) {
+    return [nodeId];
+  }
+  const node = nodeById.get(nodeId);
+  if (!node || !Array.isArray(node.childIds)) {
+    return [];
+  }
+  const output = [];
+  for (const childId of node.childIds) {
+    output.push(...collectKeptDescendants(childId, nodeById, keepIds, visited));
+  }
+  return output;
+};
+var shouldKeepCompactNode = (node) => {
+  if (node.ignored) {
+    return false;
+  }
+  const role = getAxRole(node);
+  if (role && INTERACTIVE_AX_ROLES.has(role)) {
+    return true;
+  }
+  const name = getAxName(node);
+  const hasName = name.trim().length > 0;
+  const hasValue = hasAxValue(node);
+  if (hasName || hasValue) {
+    return true;
+  }
+  const hasChildren = Array.isArray(node.childIds) && node.childIds.length > 0;
+  if (!role || DECORATIVE_AX_ROLES.has(role)) {
+    return false;
+  }
+  return hasChildren;
+};
+var compactAxSnapshot = (snapshot) => {
+  const nodes = getAxNodes(snapshot);
+  if (nodes.length === 0) {
+    return snapshot;
+  }
+  const nodeById = /* @__PURE__ */ new Map();
+  nodes.forEach((node) => {
+    if (node && typeof node.nodeId === "string") {
+      nodeById.set(node.nodeId, node);
+    }
+  });
+  const keepIds = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (!node || typeof node !== "object" || typeof node.nodeId !== "string") {
+      continue;
+    }
+    if (shouldKeepCompactNode(node)) {
+      keepIds.add(node.nodeId);
+    }
+  }
+  const filtered = nodes.filter(
+    (node) => node && typeof node.nodeId === "string" && keepIds.has(node.nodeId)
+  );
+  for (const node of filtered) {
+    if (!Array.isArray(node.childIds) || typeof node.nodeId !== "string") {
+      continue;
+    }
+    const nextChildIds = [];
+    for (const childId of node.childIds) {
+      nextChildIds.push(...collectKeptDescendants(childId, nodeById, keepIds));
+    }
+    node.childIds = Array.from(new Set(nextChildIds));
+  }
+  return replaceAxNodes(snapshot, filtered);
+};
+var applyAxSnapshotFilters = (snapshot, options) => {
+  let filtered = snapshot;
+  if (options.compact) {
+    filtered = compactAxSnapshot(filtered);
+  }
+  if (options.interactiveOnly) {
+    filtered = filterAxSnapshot(filtered, (node) => isInteractiveAxNode(node));
+  }
+  return filtered;
+};
+var truncateAxSnapshot = (snapshot, maxNodes) => {
+  const nodes = getAxNodes(snapshot);
+  if (!Number.isFinite(maxNodes) || maxNodes <= 0) {
+    return { snapshot, truncated: false };
+  }
+  if (nodes.length === 0 || nodes.length <= maxNodes) {
+    return { snapshot, truncated: false };
+  }
+  const nodeById = /* @__PURE__ */ new Map();
+  const parentCount = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!node || typeof node !== "object" || typeof node.nodeId !== "string") {
+      continue;
+    }
+    nodeById.set(node.nodeId, node);
+    parentCount.set(node.nodeId, parentCount.get(node.nodeId) ?? 0);
+  }
+  if (nodeById.size === 0) {
+    const sliced = nodes.slice(0, maxNodes);
+    for (const node of sliced) {
+      if (node && typeof node === "object" && Array.isArray(node.childIds)) {
+        node.childIds = [];
+      }
+    }
+    return {
+      snapshot: replaceAxNodes(snapshot, sliced),
+      truncated: true
+    };
+  }
+  for (const node of nodes) {
+    if (!node || typeof node !== "object" || !Array.isArray(node.childIds)) {
+      continue;
+    }
+    for (const childId of node.childIds) {
+      if (typeof childId !== "string") {
+        continue;
+      }
+      parentCount.set(childId, (parentCount.get(childId) ?? 0) + 1);
+    }
+  }
+  let roots = Array.from(nodeById.keys()).filter(
+    (id) => (parentCount.get(id) ?? 0) === 0
+  );
+  if (roots.length === 0) {
+    const first = nodes.find(
+      (node) => node && typeof node.nodeId === "string"
+    )?.nodeId;
+    if (first) {
+      roots = [first];
+    }
+  }
+  const kept = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...roots];
+  while (queue.length > 0 && kept.size < maxNodes) {
+    const id = queue.shift();
+    if (!id || visited.has(id)) {
+      continue;
+    }
+    visited.add(id);
+    const node = nodeById.get(id);
+    if (!node) {
+      continue;
+    }
+    kept.add(id);
+    if (Array.isArray(node.childIds)) {
+      for (const childId of node.childIds) {
+        if (typeof childId === "string" && !visited.has(childId)) {
+          queue.push(childId);
+        }
+      }
+    }
+  }
+  if (kept.size === 0) {
+    const fallback = [];
+    for (const node of nodes) {
+      if (fallback.length >= maxNodes) {
+        break;
+      }
+      if (node && typeof node.nodeId === "string") {
+        fallback.push(node.nodeId);
+      }
+    }
+    fallback.forEach((id) => kept.add(id));
+  }
+  const filtered = nodes.filter(
+    (node) => node && typeof node.nodeId === "string" && kept.has(node.nodeId)
+  );
+  for (const node of filtered) {
+    if (Array.isArray(node.childIds)) {
+      node.childIds = node.childIds.filter(
+        (id) => typeof id === "string" && kept.has(id)
+      );
+    }
+  }
+  return {
+    snapshot: replaceAxNodes(snapshot, filtered),
+    truncated: true
+  };
+};
+
+// packages/core/src/inspect/console.ts
+var toSourceLocation = (input) => {
+  const url = typeof input.url === "string" && input.url.length > 0 ? input.url : void 0;
+  const line = typeof input.lineNumber === "number" && Number.isFinite(input.lineNumber) ? Math.max(1, Math.floor(input.lineNumber) + 1) : void 0;
+  const column = typeof input.columnNumber === "number" && Number.isFinite(input.columnNumber) ? Math.max(1, Math.floor(input.columnNumber) + 1) : void 0;
+  if (!url && !line && !column) {
+    return void 0;
+  }
+  return {
+    ...url ? { url } : {},
+    ...line ? { line } : {},
+    ...column ? { column } : {}
+  };
+};
+var toStackFrames = (stackTrace) => {
+  const frames = [];
+  const collect = (trace) => {
+    if (!trace || typeof trace !== "object") {
+      return;
+    }
+    const callFrames = trace.callFrames;
+    if (Array.isArray(callFrames)) {
+      for (const frame of callFrames) {
+        if (!frame || typeof frame !== "object") {
+          continue;
+        }
+        const functionName = typeof frame.functionName === "string" ? String(frame.functionName) : void 0;
+        const url = typeof frame.url === "string" ? String(frame.url) : void 0;
+        const lineNumber = frame.lineNumber;
+        const columnNumber = frame.columnNumber;
+        const loc = toSourceLocation({ url, lineNumber, columnNumber });
+        frames.push({
+          ...functionName ? { functionName } : {},
+          ...loc?.url ? { url: loc.url } : {},
+          ...loc?.line ? { line: loc.line } : {},
+          ...loc?.column ? { column: loc.column } : {}
+        });
+        if (frames.length >= 50) {
+          return;
+        }
+      }
+    }
+    const parent = trace.parent;
+    if (frames.length < 50 && parent) {
+      collect(parent);
+    }
+  };
+  collect(stackTrace);
+  return frames.length > 0 ? frames : void 0;
+};
+var toRemoteObjectSummary = (obj) => {
+  if (!obj || typeof obj !== "object") {
+    return void 0;
+  }
+  const raw = obj;
+  const type = typeof raw.type === "string" ? raw.type : void 0;
+  const subtype = typeof raw.subtype === "string" ? raw.subtype : void 0;
+  const description = typeof raw.description === "string" ? raw.description : void 0;
+  const unserializableValue = typeof raw.unserializableValue === "string" ? raw.unserializableValue : void 0;
+  const out = {};
+  if (type) out.type = type;
+  if (subtype) out.subtype = subtype;
+  if (description) out.description = description;
+  if (raw.value !== void 0) out.value = raw.value;
+  if (unserializableValue) out.unserializableValue = unserializableValue;
+  return Object.keys(out).length > 0 ? out : void 0;
+};
+var stringifyRemoteObject = (value) => {
+  if (!value || typeof value !== "object") {
+    return String(value ?? "");
+  }
+  const obj = value;
+  if (obj.unserializableValue) {
+    return obj.unserializableValue;
+  }
+  if (obj.value !== void 0) {
+    try {
+      return typeof obj.value === "string" ? obj.value : JSON.stringify(obj.value);
+    } catch {
+      return String(obj.value);
+    }
+  }
+  if (obj.description) {
+    return obj.description;
+  }
+  return obj.type ?? "";
+};
+var toConsoleEntry = (event) => {
+  const params = event.params ?? {};
+  switch (event.method) {
+    case "Runtime.consoleAPICalled": {
+      const rawArgs = Array.isArray(params.args) ? params.args : [];
+      const text = rawArgs.map((arg) => stringifyRemoteObject(arg)).join(" ");
+      const level = String(params.type ?? "log");
+      const stack = toStackFrames(
+        params.stackTrace
+      );
+      const args = rawArgs.map((arg) => toRemoteObjectSummary(arg)).filter((entry) => Boolean(entry));
+      return {
+        level,
+        text,
+        timestamp: event.timestamp,
+        ...stack && stack.length > 0 ? { stack } : {},
+        ...args.length > 0 ? { args } : {}
+      };
+    }
+    case "Runtime.exceptionThrown": {
+      const details = params.exceptionDetails;
+      const exception = toRemoteObjectSummary(details?.exception);
+      const stack = toStackFrames(details?.stackTrace);
+      const source = toSourceLocation({
+        url: details?.url,
+        lineNumber: details?.lineNumber,
+        columnNumber: details?.columnNumber
+      }) ?? // If the top frame exists, treat it as the source.
+      (stack && stack.length > 0 ? {
+        url: stack[0].url,
+        line: stack[0].line,
+        column: stack[0].column
+      } : void 0);
+      const baseText = typeof details?.text === "string" && details.text.trim().length > 0 ? details.text : "Uncaught exception";
+      const exceptionDesc = typeof exception?.description === "string" && exception.description.trim().length > 0 ? exception.description : void 0;
+      const text = baseText === "Uncaught" && exceptionDesc ? `Uncaught: ${exceptionDesc}` : baseText;
+      return {
+        level: "error",
+        text,
+        timestamp: event.timestamp,
+        ...source ? { source } : {},
+        ...stack && stack.length > 0 ? { stack } : {},
+        ...exception ? { exception } : {}
+      };
+    }
+    case "Log.entryAdded": {
+      const entry = params.entry;
+      if (!entry) {
+        return null;
+      }
+      const stack = toStackFrames(entry.stackTrace);
+      const source = toSourceLocation({
+        url: entry.url,
+        lineNumber: entry.lineNumber,
+        columnNumber: void 0
+      });
+      return {
+        level: entry.level ?? "log",
+        text: entry.text ?? "",
+        timestamp: event.timestamp,
+        ...source ? { source } : {},
+        ...stack && stack.length > 0 ? { stack } : {}
+      };
+    }
+    default:
+      return null;
+  }
+};
+
+// packages/core/src/inspect/har.ts
+var buildHar = (events, title) => {
+  const requests = /* @__PURE__ */ new Map();
+  const toTimestamp = (event, fallback) => {
+    const raw = event.params?.wallTime;
+    if (typeof raw === "number") {
+      return raw * 1e3;
+    }
+    const ts = event.params?.timestamp;
+    if (typeof ts === "number") {
+      return ts * 1e3;
+    }
+    const parsed = Date.parse(event.timestamp);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+    return fallback ?? Date.now();
+  };
+  for (const event of events) {
+    const params = event.params ?? {};
+    switch (event.method) {
+      case "Network.requestWillBeSent": {
+        const requestId = String(params.requestId);
+        if (!requestId) {
+          break;
+        }
+        const request = params.request;
+        const record = {
+          id: requestId,
+          url: request?.url,
+          method: request?.method,
+          requestHeaders: request?.headers ?? {},
+          startTime: toTimestamp(event)
+        };
+        requests.set(requestId, record);
+        break;
+      }
+      case "Network.responseReceived": {
+        const requestId = String(params.requestId);
+        if (!requestId) {
+          break;
+        }
+        const response = params.response;
+        const record = requests.get(requestId) ?? { id: requestId };
+        record.status = response?.status;
+        record.statusText = response?.statusText;
+        record.mimeType = response?.mimeType;
+        record.responseHeaders = response?.headers ?? {};
+        record.protocol = response?.protocol;
+        record.startTime = record.startTime ?? toTimestamp(event);
+        requests.set(requestId, record);
+        break;
+      }
+      case "Network.loadingFinished": {
+        const requestId = String(params.requestId);
+        if (!requestId) {
+          break;
+        }
+        const record = requests.get(requestId) ?? { id: requestId };
+        record.encodedDataLength = params.encodedDataLength;
+        record.endTime = toTimestamp(event, record.startTime);
+        requests.set(requestId, record);
+        break;
+      }
+      case "Network.loadingFailed": {
+        const requestId = String(params.requestId);
+        if (!requestId) {
+          break;
+        }
+        const record = requests.get(requestId) ?? { id: requestId };
+        record.endTime = toTimestamp(event, record.startTime);
+        requests.set(requestId, record);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const entries = Array.from(requests.values()).map((record) => {
+    const started = record.startTime ?? Date.now();
+    const ended = record.endTime ?? started;
+    const time = Math.max(0, ended - started);
+    const url = record.url ?? "";
+    const queryString = [];
+    try {
+      const parsed = new URL(url);
+      parsed.searchParams.forEach((value, name) => {
+        queryString.push({ name, value });
+      });
+    } catch {
+    }
+    return {
+      pageref: "page_0",
+      startedDateTime: new Date(started).toISOString(),
+      time,
+      request: {
+        method: record.method ?? "GET",
+        url,
+        httpVersion: record.protocol ?? "HTTP/1.1",
+        cookies: [],
+        headers: [],
+        queryString,
+        headersSize: -1,
+        bodySize: -1
+      },
+      response: {
+        status: record.status ?? 0,
+        statusText: record.statusText ?? "",
+        httpVersion: record.protocol ?? "HTTP/1.1",
+        cookies: [],
+        headers: [],
+        redirectURL: "",
+        headersSize: -1,
+        bodySize: record.encodedDataLength ?? 0,
+        content: {
+          size: record.encodedDataLength ?? 0,
+          mimeType: record.mimeType ?? ""
+        }
+      },
+      cache: {},
+      timings: {
+        send: 0,
+        wait: time,
+        receive: 0
+      }
+    };
+  });
+  const startedDateTime = entries.length ? entries[0].startedDateTime ?? (/* @__PURE__ */ new Date()).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    log: {
+      version: "1.2",
+      creator: {
+        name: "browser-bridge",
+        version: "0.0.0"
+      },
+      pages: [
+        {
+          id: "page_0",
+          title: title ?? "page",
+          startedDateTime,
+          pageTimings: {
+            onContentLoad: -1,
+            onLoad: -1
+          }
+        }
+      ],
+      entries
+    }
+  };
+};
+
+// packages/core/src/inspect/html-snapshot.ts
+var captureHtml = async (tabId, options) => {
+  await options.debuggerCommand(tabId, "Runtime.enable", {});
+  const expression = options.selector ? `(() => { try { const el = document.querySelector(${JSON.stringify(
+    options.selector
+  )}); return el ? el.outerHTML : ""; } catch { return ""; } })()` : "document.documentElement ? document.documentElement.outerHTML : ''";
+  const result = await options.debuggerCommand(tabId, "Runtime.evaluate", {
+    expression,
+    returnByValue: true,
+    awaitPromise: true
+  });
+  if (result && typeof result === "object" && "exceptionDetails" in result) {
+    return options.onEvaluationFailed();
+  }
+  return String(
+    result?.result?.value ?? ""
+  );
+};
+var collectHtmlEntries = (html) => {
+  const entries = /* @__PURE__ */ new Map();
+  const tagPattern = /<([a-zA-Z0-9-]+)([^>]*)>/g;
+  let match;
+  let index = 0;
+  while ((match = tagPattern.exec(html)) && entries.size < 1e3) {
+    const tag = match[1].toLowerCase();
+    const attrs = match[2] ?? "";
+    const idMatch = /\bid=["']([^"']+)["']/.exec(attrs);
+    const classMatch = /\bclass=["']([^"']+)["']/.exec(attrs);
+    const id = idMatch?.[1];
+    const className = classMatch?.[1]?.split(/\s+/)[0];
+    let key = tag;
+    if (id) {
+      key = `${tag}#${id}`;
+    } else if (className) {
+      key = `${tag}.${className}`;
+    } else {
+      key = `${tag}:nth-${index}`;
+    }
+    entries.set(key, attrs.trim());
+    index += 1;
+  }
+  return entries;
+};
+
+// packages/core/src/inspect/snapshot-history.ts
+var SnapshotHistory = class {
+  constructor(options) {
+    this.history = [];
+    this.maxSnapshotsPerSession = Math.max(0, options.maxSnapshotsPerSession);
+    this.maxSnapshotHistory = Math.max(0, options.maxSnapshotHistory);
+  }
+  record(sessionId, snapshot) {
+    const entries = this.collectSnapshotEntries(snapshot);
+    if (!entries) {
+      return;
+    }
+    this.history.push({
+      sessionId,
+      format: snapshot.format,
+      entries,
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    let count = 0;
+    for (const record of this.history) {
+      if (record.sessionId === sessionId) {
+        count += 1;
+      }
+    }
+    while (count > this.maxSnapshotsPerSession) {
+      const index = this.history.findIndex(
+        (record) => record.sessionId === sessionId
+      );
+      if (index === -1) {
+        break;
+      }
+      this.history.splice(index, 1);
+      count -= 1;
+    }
+    while (this.history.length > this.maxSnapshotHistory) {
+      this.history.shift();
+    }
+  }
+  diff(sessionId) {
+    const snapshots = this.history.filter(
+      (record) => record.sessionId === sessionId
+    );
+    if (snapshots.length < 2) {
+      return {
+        added: [],
+        removed: [],
+        changed: [],
+        summary: "Not enough snapshots to diff."
+      };
+    }
+    const previous = snapshots[snapshots.length - 2];
+    const current = snapshots[snapshots.length - 1];
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [key, value] of current.entries.entries()) {
+      if (!previous.entries.has(key)) {
+        added.push(key);
+      } else if (previous.entries.get(key) !== value) {
+        changed.push(key);
+      }
+    }
+    for (const key of previous.entries.keys()) {
+      if (!current.entries.has(key)) {
+        removed.push(key);
+      }
+    }
+    return {
+      added,
+      removed,
+      changed,
+      summary: `Added ${added.length}, removed ${removed.length}, changed ${changed.length}.`
+    };
+  }
+  collectSnapshotEntries(snapshot) {
+    if (snapshot.format === "html" && typeof snapshot.snapshot === "string") {
+      return collectHtmlEntries(snapshot.snapshot);
+    }
+    if (snapshot.format === "ax") {
+      return this.collectAxEntries(snapshot.snapshot);
+    }
+    return null;
+  }
+  collectAxEntries(snapshot) {
+    const entries = /* @__PURE__ */ new Map();
+    const nodes = getAxNodes(snapshot);
+    if (nodes.length === 0) {
+      return entries;
+    }
+    nodes.forEach((node, index) => {
+      if (!node || typeof node !== "object") {
+        return;
+      }
+      const record = node;
+      const role = typeof record.role === "string" ? record.role : record.role?.value ?? "node";
+      const name = typeof record.name === "string" ? record.name : record.name?.value ?? "";
+      const nodeId = record.nodeId ?? (record.backendDOMNodeId !== void 0 ? String(record.backendDOMNodeId) : void 0);
+      const key = nodeId ? `node-${nodeId}` : `${role}:${name}:${index}`;
+      entries.set(key, `${role}:${name}`);
+    });
+    return entries;
+  }
+};
+
+// packages/core/src/inspect/snapshot-refs.ts
+var SNAPSHOT_REF_ATTRIBUTE = "data-bv-ref";
+var MAX_REF_ASSIGNMENTS = 500;
+var MAX_REF_WARNINGS = 5;
+var isInspectError = (error) => Boolean(
+  error && typeof error === "object" && "name" in error && error.name === "InspectError" && "message" in error && typeof error.message === "string"
+);
+var assignRefsToAxSnapshot = (snapshot) => {
+  const nodes = getAxNodes(snapshot);
+  const refs = /* @__PURE__ */ new Map();
+  let index = 1;
+  for (const node of nodes) {
+    if (!node || typeof node !== "object") {
+      continue;
+    }
+    if (node.ignored) {
+      continue;
+    }
+    const backendId = node.backendDOMNodeId;
+    if (typeof backendId !== "number") {
+      continue;
+    }
+    const ref = `@e${index}`;
+    index += 1;
+    node.ref = ref;
+    refs.set(backendId, ref);
+  }
+  return refs;
+};
+var clearSnapshotRefs = async (tabId, debuggerCommand) => {
+  await debuggerCommand(tabId, "Runtime.evaluate", {
+    expression: `document.querySelectorAll('[${SNAPSHOT_REF_ATTRIBUTE}]').forEach((el) => el.removeAttribute('${SNAPSHOT_REF_ATTRIBUTE}'))`,
+    returnByValue: true,
+    awaitPromise: true
+  });
+};
+var applySnapshotRefs = async (tabId, refs, debuggerCommand) => {
+  const warnings = [];
+  await debuggerCommand(tabId, "DOM.enable", {});
+  await debuggerCommand(tabId, "Runtime.enable", {});
+  try {
+    await clearSnapshotRefs(tabId, debuggerCommand);
+  } catch {
+    warnings.push("Failed to clear prior snapshot refs.");
+  }
+  if (refs.size === 0) {
+    return warnings;
+  }
+  let applied = 0;
+  for (const [backendNodeId, ref] of refs) {
+    if (applied >= MAX_REF_ASSIGNMENTS) {
+      warnings.push(
+        `Snapshot refs truncated at ${MAX_REF_ASSIGNMENTS} elements.`
+      );
+      break;
+    }
+    try {
+      const described = await debuggerCommand(tabId, "DOM.describeNode", {
+        backendNodeId
+      });
+      const node = described.node;
+      if (!node || node.nodeType !== 1 || typeof node.nodeId !== "number") {
+        if (warnings.length < MAX_REF_WARNINGS) {
+          warnings.push(`Ref ${ref} could not be applied to a DOM element.`);
+        }
+        continue;
+      }
+      await debuggerCommand(tabId, "DOM.setAttributeValue", {
+        nodeId: node.nodeId,
+        name: SNAPSHOT_REF_ATTRIBUTE,
+        value: ref
+      });
+      applied += 1;
+    } catch {
+      if (warnings.length < MAX_REF_WARNINGS) {
+        warnings.push(`Ref ${ref} could not be applied.`);
+      }
+    }
+  }
+  return warnings;
+};
+var resolveNodeIdForSelector = async (tabId, selector, debuggerCommand) => {
+  await debuggerCommand(tabId, "DOM.enable", {});
+  const document = await debuggerCommand(tabId, "DOM.getDocument", {
+    depth: 1
+  });
+  const rootNodeId = document.root?.nodeId;
+  if (typeof rootNodeId !== "number") {
+    return { warnings: ["Failed to resolve DOM root for selector."] };
+  }
+  try {
+    const result = await debuggerCommand(tabId, "DOM.querySelector", {
+      nodeId: rootNodeId,
+      selector
+    });
+    const nodeId = result.nodeId;
+    if (!nodeId) {
+      return { warnings: [`Selector not found: ${selector}`] };
+    }
+    return { nodeId };
+  } catch (error) {
+    if (isInspectError(error)) {
+      return { warnings: [error.message] };
+    }
+    return { warnings: ["Selector query failed."] };
+  }
+};
+
+// packages/core/src/page-state-script.ts
+var PAGE_STATE_SCRIPT = [
+  "(() => {",
+  "  const escape = (value) => {",
+  "    if (typeof CSS !== 'undefined' && typeof CSS.escape === 'function') {",
+  "      return CSS.escape(value);",
+  "    }",
+  `    return String(value).replace(/["'\\\\]/g, '\\\\$&');`,
+  "  };",
+  "  const truncate = (value, max) => {",
+  "    const text = String(value ?? '');",
+  "    return text.length > max ? text.slice(0, max) : text;",
+  "  };",
+  "  const selectorFor = (element) => {",
+  "    if (element.id) {",
+  "      return `#${escape(element.id)}`;",
+  "    }",
+  "    const name = element.getAttribute('name');",
+  "    if (name) {",
+  '      return `${element.tagName.toLowerCase()}[name="${escape(name)}"]`;',
+  "    }",
+  "    const parts = [];",
+  "    let node = element;",
+  "    while (node && node.nodeType === 1 && parts.length < 4) {",
+  "      let part = node.tagName.toLowerCase();",
+  "      const parent = node.parentElement;",
+  "      if (parent) {",
+  "        const siblings = Array.from(parent.children).filter(",
+  "          (child) => child.tagName === node.tagName",
+  "        );",
+  "        if (siblings.length > 1) {",
+  "          part += `:nth-of-type(${siblings.indexOf(node) + 1})`;",
+  "        }",
+  "      }",
+  "      parts.unshift(part);",
+  "      node = parent;",
+  "    }",
+  "    return parts.join('>');",
+  "  };",
+  "  const readStorage = (storage, limit) => {",
+  "    try {",
+  "      return Object.keys(storage)",
+  "        .slice(0, limit)",
+  "        .map((key) => ({",
+  "          key,",
+  "          value: truncate(storage.getItem(key), 500),",
+  "        }));",
+  "    } catch {",
+  "      return [];",
+  "    }",
+  "  };",
+  "  const forms = Array.from(document.querySelectorAll('form')).map((form) => {",
+  "    const fields = Array.from(form.elements)",
+  "      .filter((element) => element && element.tagName)",
+  "      .map((element) => {",
+  "        const tag = element.tagName.toLowerCase();",
+  "        const type = 'type' in element && element.type ? element.type : tag;",
+  "        const name = element.name || element.getAttribute('name') || element.id || '';",
+  "        let value = '';",
+  "        let options;",
+  "        if (tag === 'select') {",
+  "          const select = element;",
+  "          value = select.value ?? '';",
+  "          options = Array.from(select.options).map((option) => option.text);",
+  "        } else if (tag === 'input' && element.type === 'password') {",
+  "          value = '[redacted]';",
+  "        } else if (tag === 'input' || tag === 'textarea') {",
+  "          value = element.value ?? '';",
+  "        } else if (element.isContentEditable) {",
+  "          value = element.textContent ?? '';",
+  "        } else if ('value' in element) {",
+  "          value = element.value ?? '';",
+  "        }",
+  "        return {",
+  "          name,",
+  "          type,",
+  "          value: truncate(value, 500),",
+  "          ...(options ? { options } : {}),",
+  "        };",
+  "      });",
+  "    return {",
+  "      selector: selectorFor(form),",
+  "      action: form.getAttribute('action') || undefined,",
+  "      method: form.getAttribute('method') || undefined,",
+  "      fields,",
+  "    };",
+  "  });",
+  "  const localStorage = readStorage(window.localStorage, 100);",
+  "  const sessionStorage = readStorage(window.sessionStorage, 100);",
+  "  const cookies = (document.cookie ? document.cookie.split(';') : [])",
+  "    .map((entry) => entry.trim())",
+  "    .filter((entry) => entry.length > 0)",
+  "    .slice(0, 50)",
+  "    .map((entry) => {",
+  "      const [key, ...rest] = entry.split('=');",
+  "      return { key, value: truncate(rest.join('='), 500) };",
+  "    });",
+  "  return { forms, localStorage, sessionStorage, cookies };",
+  "})()"
+].join("\n");
+
+// packages/core/src/target-matching.ts
+var normalizeText = (value) => (value ?? "").trim().toLowerCase();
+var normalizeUrl = (value) => {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    return "";
+  }
+  const hashIndex = normalized.indexOf("#");
+  const withoutHash = hashIndex >= 0 ? normalized.slice(0, hashIndex) : normalized;
+  return withoutHash.endsWith("/") && withoutHash.length > 1 ? withoutHash.slice(0, -1) : withoutHash;
+};
+var scoreUrlMatch = (candidateUrl, hintUrl) => {
+  if (!candidateUrl || !hintUrl) {
+    return 0;
+  }
+  if (candidateUrl === hintUrl) {
+    return 100;
+  }
+  if (candidateUrl.includes(hintUrl) || hintUrl.includes(candidateUrl)) {
+    return 60;
+  }
+  return 0;
+};
+var scoreTitleMatch = (candidateTitle, hintTitle) => {
+  if (!candidateTitle || !hintTitle) {
+    return 0;
+  }
+  if (candidateTitle === hintTitle) {
+    return 80;
+  }
+  if (candidateTitle.includes(hintTitle) || hintTitle.includes(candidateTitle)) {
+    return 40;
+  }
+  return 0;
+};
+var scoreRecency = (lastSeenAt, now) => {
+  if (!lastSeenAt) {
+    return 0;
+  }
+  const ageMinutes = Math.max(0, (now - lastSeenAt) / 6e4);
+  return Math.max(0, 30 - ageMinutes);
+};
+var scoreHintRecency = (lastSeenAt, hintLastActiveAt) => {
+  if (!lastSeenAt || !hintLastActiveAt) {
+    return 0;
+  }
+  const deltaMinutes = Math.abs(lastSeenAt - hintLastActiveAt) / 6e4;
+  return Math.max(0, 20 - deltaMinutes);
+};
+var isBlankUrl = (url) => url.length === 0 || url === "about:blank";
+var rankTargetCandidates = (candidates, hint, now = Date.now()) => {
+  const normalizedHintUrl = normalizeUrl(hint?.url);
+  const normalizedHintTitle = normalizeText(hint?.title);
+  const hintLastActiveAt = hint?.lastActiveAt ? Date.parse(hint.lastActiveAt) : void 0;
+  const ranked = candidates.map((candidate) => {
+    const reasons = [];
+    const normalizedUrl = normalizeUrl(candidate.url);
+    const normalizedTitle = normalizeText(candidate.title);
+    let score = 0;
+    const urlScore = scoreUrlMatch(normalizedUrl, normalizedHintUrl);
+    if (urlScore > 0) {
+      score += urlScore;
+      reasons.push(urlScore >= 100 ? "url:exact" : "url:partial");
+    }
+    const titleScore = scoreTitleMatch(normalizedTitle, normalizedHintTitle);
+    if (titleScore > 0) {
+      score += titleScore;
+      reasons.push(titleScore >= 80 ? "title:exact" : "title:partial");
+    }
+    const recencyScore = scoreRecency(candidate.lastSeenAt, now);
+    if (recencyScore > 0) {
+      score += recencyScore;
+      reasons.push("recency");
+    }
+    const hintRecencyScore = scoreHintRecency(
+      candidate.lastSeenAt,
+      Number.isFinite(hintLastActiveAt) ? hintLastActiveAt : void 0
+    );
+    if (hintRecencyScore > 0) {
+      score += hintRecencyScore;
+      reasons.push("hint-recency");
+    }
+    if (isBlankUrl(normalizedUrl)) {
+      score -= 50;
+      reasons.push("blank-url");
+    }
+    return { candidate, score, reasons };
+  });
+  return ranked.sort((a, b) => {
+    if (a.score !== b.score) {
+      return b.score - a.score;
+    }
+    const aSeen = a.candidate.lastSeenAt ?? 0;
+    const bSeen = b.candidate.lastSeenAt ?? 0;
+    if (aSeen !== bSeen) {
+      return bSeen - aSeen;
+    }
+    return a.candidate.url.localeCompare(b.candidate.url);
+  });
+};
+var pickBestTarget = (candidates, hint, now = Date.now()) => {
+  const ranked = rankTargetCandidates(candidates, hint, now);
+  return ranked.length > 0 ? ranked[0] : null;
+};
+
+// packages/core/src/inspect/service.ts
+var DEFAULT_MAX_SNAPSHOTS_PER_SESSION = 20;
+var DEFAULT_MAX_SNAPSHOT_HISTORY = 100;
+var InspectService = class {
+  constructor(options) {
+    this.registry = options.registry;
+    this.debugger = options.debuggerBridge;
+    this.extensionBridge = options.extensionBridge;
+    const maxSnapshotsPerSession = options.maxSnapshotsPerSession ?? DEFAULT_MAX_SNAPSHOTS_PER_SESSION;
+    const maxSnapshotHistory = options.maxSnapshotHistory ?? DEFAULT_MAX_SNAPSHOT_HISTORY;
+    this.snapshots = new SnapshotHistory({
+      maxSnapshotsPerSession,
+      maxSnapshotHistory
+    });
+  }
+  isConnected() {
+    return this.debugger?.hasAttachments() ?? false;
+  }
+  getLastError() {
+    if (!this.lastError || !this.lastErrorAt) {
+      const debuggerError = this.debugger?.getLastError();
+      if (!debuggerError) {
+        return void 0;
+      }
       return {
         error: new InspectError(
           "INSPECT_UNAVAILABLE",
@@ -1225,9 +2097,22 @@ var InspectService = class {
   async domSnapshot(input) {
     this.requireSession(input.sessionId);
     const selection = await this.resolveTab(input.targetHint);
+    const debuggerCommand = this.debuggerCommand.bind(this);
     const work = async () => {
       if (input.format === "html") {
-        const html = await this.captureHtml(selection.tabId, input.selector);
+        const html = await captureHtml(selection.tabId, {
+          selector: input.selector,
+          debuggerCommand,
+          onEvaluationFailed: () => {
+            const error = new InspectError(
+              "EVALUATION_FAILED",
+              "Failed to evaluate HTML snapshot.",
+              { retryable: false }
+            );
+            this.recordError(error);
+            throw error;
+          }
+        });
         const warnings = [...selection.warnings ?? []];
         if (input.interactive) {
           warnings.push(
@@ -1254,17 +2139,19 @@ var InspectService = class {
         const selectorWarnings = [];
         let result2;
         if (input.selector) {
-          const resolved = await this.resolveNodeIdForSelector(
+          const resolved = await resolveNodeIdForSelector(
             selection.tabId,
-            input.selector
+            input.selector,
+            debuggerCommand
           );
           selectorWarnings.push(...resolved.warnings ?? []);
           if (!resolved.nodeId) {
             let refWarnings2 = [];
             try {
-              refWarnings2 = await this.applySnapshotRefs(
+              refWarnings2 = await applySnapshotRefs(
                 selection.tabId,
-                /* @__PURE__ */ new Map()
+                /* @__PURE__ */ new Map(),
+                debuggerCommand
               );
             } catch {
               refWarnings2 = ["Failed to clear prior snapshot refs."];
@@ -1292,17 +2179,14 @@ var InspectService = class {
             {}
           );
         }
-        let snapshot = input.interactive || input.compact ? this.applyAxSnapshotFilters(result2, {
+        let snapshot = input.interactive || input.compact ? applyAxSnapshotFilters(result2, {
           interactiveOnly: input.interactive,
           compact: input.compact
         }) : result2;
         let truncated = false;
         const truncationWarnings = [];
         if (input.maxNodes !== void 0) {
-          const truncatedResult = this.truncateAxSnapshot(
-            snapshot,
-            input.maxNodes
-          );
+          const truncatedResult = truncateAxSnapshot(snapshot, input.maxNodes);
           snapshot = truncatedResult.snapshot;
           truncated = truncatedResult.truncated;
           if (truncated) {
@@ -1311,10 +2195,11 @@ var InspectService = class {
             );
           }
         }
-        const refMap = this.assignRefsToAxSnapshot(snapshot);
-        const refWarnings = await this.applySnapshotRefs(
+        const refMap = assignRefsToAxSnapshot(snapshot);
+        const refWarnings = await applySnapshotRefs(
           selection.tabId,
-          refMap
+          refMap,
+          debuggerCommand
         );
         const warnings = [
           ...selection.warnings ?? [],
@@ -1338,7 +2223,19 @@ var InspectService = class {
           if (!fallbackCodes.includes(error.code)) {
             throw error;
           }
-          const html = await this.captureHtml(selection.tabId, input.selector);
+          const html = await captureHtml(selection.tabId, {
+            selector: input.selector,
+            debuggerCommand,
+            onEvaluationFailed: () => {
+              const error2 = new InspectError(
+                "EVALUATION_FAILED",
+                "Failed to evaluate HTML snapshot.",
+                { retryable: false }
+              );
+              this.recordError(error2);
+              throw error2;
+            }
+          });
           const warnings = [
             ...selection.warnings ?? [],
             "AX snapshot failed; returned HTML instead.",
@@ -1358,52 +2255,19 @@ var InspectService = class {
     };
     if (input.consistency === "quiesce") {
       const result2 = await driveMutex.runExclusive(work);
-      this.recordSnapshot(input.sessionId, result2);
+      this.snapshots.record(input.sessionId, result2);
       this.markInspectConnected(input.sessionId);
       return result2;
     }
     const result = await work();
-    this.recordSnapshot(input.sessionId, result);
+    this.snapshots.record(input.sessionId, result);
     this.markInspectConnected(input.sessionId);
     return result;
   }
   domDiff(input) {
     this.requireSession(input.sessionId);
     this.markInspectConnected(input.sessionId);
-    const snapshots = this.snapshotHistory.filter(
-      (record) => record.sessionId === input.sessionId
-    );
-    if (snapshots.length < 2) {
-      return {
-        added: [],
-        removed: [],
-        changed: [],
-        summary: "Not enough snapshots to diff."
-      };
-    }
-    const previous = snapshots[snapshots.length - 2];
-    const current = snapshots[snapshots.length - 1];
-    const added = [];
-    const removed = [];
-    const changed = [];
-    for (const [key, value] of current.entries.entries()) {
-      if (!previous.entries.has(key)) {
-        added.push(key);
-      } else if (previous.entries.get(key) !== value) {
-        changed.push(key);
-      }
-    }
-    for (const key of previous.entries.keys()) {
-      if (!current.entries.has(key)) {
-        removed.push(key);
-      }
-    }
-    return {
-      added,
-      removed,
-      changed,
-      summary: `Added ${added.length}, removed ${removed.length}, changed ${changed.length}.`
-    };
+    return this.snapshots.diff(input.sessionId);
   }
   async find(input) {
     const snapshot = await this.domSnapshot({
@@ -1420,12 +2284,12 @@ var InspectService = class {
         ...warnings.length > 0 ? { warnings } : {}
       };
     }
-    const nodes = this.getAxNodes(snapshot.snapshot);
+    const nodes = getAxNodes(snapshot.snapshot);
     const matches = [];
-    const nameQuery = typeof input.name === "string" ? this.normalizeQuery(input.name) : "";
-    const textQuery = typeof input.text === "string" ? this.normalizeQuery(input.text) : "";
-    const labelQuery = typeof input.label === "string" ? this.normalizeQuery(input.label) : "";
-    const roleQuery = typeof input.role === "string" ? this.normalizeQuery(input.role) : "";
+    const nameQuery = typeof input.name === "string" ? normalizeQuery(input.name) : "";
+    const textQuery = typeof input.text === "string" ? normalizeQuery(input.text) : "";
+    const labelQuery = typeof input.label === "string" ? normalizeQuery(input.label) : "";
+    const roleQuery = typeof input.role === "string" ? normalizeQuery(input.role) : "";
     for (const node of nodes) {
       if (!node || typeof node !== "object") {
         continue;
@@ -1433,24 +2297,24 @@ var InspectService = class {
       if (typeof node.ref !== "string" || node.ref.length === 0) {
         continue;
       }
-      const role = this.getAxRole(node);
-      const name = this.getAxName(node);
+      const role = getAxRole(node);
+      const name = getAxName(node);
       if (input.kind === "role") {
         if (!role || role !== roleQuery) {
           continue;
         }
-        if (nameQuery && !this.matchesTextValue(name, nameQuery)) {
+        if (nameQuery && !matchesTextValue(name, nameQuery)) {
           continue;
         }
       } else if (input.kind === "text") {
-        if (!textQuery || !this.matchesAxText(node, textQuery)) {
+        if (!textQuery || !matchesAxText(node, textQuery)) {
           continue;
         }
       } else if (input.kind === "label") {
         if (!labelQuery || !LABEL_AX_ROLES.has(role)) {
           continue;
         }
-        if (!this.matchesTextValue(name, labelQuery)) {
+        if (!matchesTextValue(name, labelQuery)) {
           continue;
         }
       }
@@ -1458,835 +2322,440 @@ var InspectService = class {
         ref: node.ref,
         ...role ? { role } : {},
         ...name ? { name } : {}
-      });
-    }
-    return {
-      matches,
-      ...warnings.length > 0 ? { warnings } : {}
-    };
-  }
-  async consoleList(input) {
-    this.requireSession(input.sessionId);
-    const selection = await this.resolveTab(input.targetHint);
-    await this.enableConsole(selection.tabId);
-    const events = this.ensureDebugger().getConsoleEvents(selection.tabId);
-    const entries = events.map((event) => this.toConsoleEntry(event)).filter((entry) => entry !== null);
-    const result = {
-      entries,
-      warnings: selection.warnings
-    };
-    this.markInspectConnected(input.sessionId);
-    return result;
-  }
-  async networkHar(input) {
-    this.requireSession(input.sessionId);
-    const selection = await this.resolveTab(input.targetHint);
-    await this.enableNetwork(selection.tabId);
-    const events = this.ensureDebugger().getNetworkEvents(selection.tabId);
-    const har = this.buildHar(events, selection.tab.title);
-    try {
-      const rootDir = await ensureArtifactRootDir(input.sessionId);
-      const artifactId = (0, import_crypto3.randomUUID)();
-      const filePath = import_node_path2.default.join(rootDir, `har-${artifactId}.json`);
-      await (0, import_promises2.writeFile)(filePath, JSON.stringify(har, null, 2), "utf-8");
-      const result = {
-        artifact_id: artifactId,
-        path: filePath,
-        mime: "application/json"
-      };
-      this.markInspectConnected(input.sessionId);
-      return result;
-    } catch {
-      const error = new InspectError(
-        "ARTIFACT_IO_ERROR",
-        "Failed to write HAR file."
-      );
-      this.recordError(error);
-      throw error;
-    }
-  }
-  async evaluate(input) {
-    this.requireSession(input.sessionId);
-    const selection = await this.resolveTab(input.targetHint);
-    const expression = input.expression ?? "undefined";
-    await this.debuggerCommand(selection.tabId, "Runtime.enable", {});
-    const result = await this.debuggerCommand(
-      selection.tabId,
-      "Runtime.evaluate",
-      {
-        expression,
-        returnByValue: true,
-        awaitPromise: true
-      }
-    );
-    if (result && typeof result === "object" && "exceptionDetails" in result) {
-      const output2 = {
-        exception: result.exceptionDetails,
-        warnings: selection.warnings
-      };
-      this.markInspectConnected(input.sessionId);
-      return output2;
-    }
-    const output = {
-      value: result?.result?.value,
-      warnings: selection.warnings
-    };
-    this.markInspectConnected(input.sessionId);
-    return output;
-  }
-  async extractContent(input) {
-    this.requireSession(input.sessionId);
-    const selection = await this.resolveTab(input.targetHint);
-    const html = await this.captureHtml(selection.tabId);
-    const url = selection.tab.url ?? "about:blank";
-    let article = null;
-    try {
-      const dom = new import_jsdom.JSDOM(html, { url });
-      const reader = new import_readability.Readability(dom.window.document);
-      article = reader.parse();
-    } catch {
-      const err = new InspectError(
-        "EVALUATION_FAILED",
-        "Failed to parse page content.",
-        { retryable: false }
-      );
-      this.recordError(err);
-      throw err;
-    }
-    if (!article) {
-      const err = new InspectError(
-        "NOT_SUPPORTED",
-        "Readability could not extract content.",
-        { retryable: false }
-      );
-      this.recordError(err);
-      throw err;
-    }
-    let content = "";
-    if (input.format === "article_json") {
-      content = JSON.stringify(article, null, 2);
-    } else if (input.format === "text") {
-      content = article.textContent ?? "";
-    } else {
-      const turndown = new import_turndown.default();
-      content = turndown.turndown(article.content ?? "");
-    }
-    const warnings = selection.warnings ?? [];
-    const includeMetadata = input.includeMetadata ?? true;
-    const output = {
-      content,
-      ...includeMetadata ? {
-        title: article.title ?? void 0,
-        byline: article.byline ?? void 0,
-        excerpt: article.excerpt ?? void 0,
-        siteName: article.siteName ?? void 0
-      } : {},
-      ...warnings.length > 0 ? { warnings } : {}
-    };
-    this.markInspectConnected(input.sessionId);
-    return output;
-  }
-  async pageState(input) {
-    this.requireSession(input.sessionId);
-    const selection = await this.resolveTab(input.targetHint);
-    await this.debuggerCommand(selection.tabId, "Runtime.enable", {});
-    const expression = PAGE_STATE_SCRIPT;
-    const result = await this.debuggerCommand(
-      selection.tabId,
-      "Runtime.evaluate",
-      {
-        expression,
-        returnByValue: true,
-        awaitPromise: true
-      }
-    );
-    if (result && typeof result === "object" && "exceptionDetails" in result) {
-      const error = new InspectError(
-        "EVALUATION_FAILED",
-        "Failed to capture page state.",
-        { retryable: false }
-      );
-      this.recordError(error);
-      throw error;
+      });
     }
-    const value = result?.result?.value;
-    const raw = value && typeof value === "object" ? value : {};
-    const warnings = [
-      ...Array.isArray(raw.warnings) ? raw.warnings : [],
-      ...selection.warnings ?? []
-    ];
-    const output = {
-      forms: Array.isArray(raw.forms) ? raw.forms : [],
-      localStorage: Array.isArray(raw.localStorage) ? raw.localStorage : [],
-      sessionStorage: Array.isArray(raw.sessionStorage) ? raw.sessionStorage : [],
-      cookies: Array.isArray(raw.cookies) ? raw.cookies : [],
+    return {
+      matches,
       ...warnings.length > 0 ? { warnings } : {}
     };
-    this.markInspectConnected(input.sessionId);
-    return output;
   }
-  async performanceMetrics(input) {
+  async consoleList(input) {
     this.requireSession(input.sessionId);
     const selection = await this.resolveTab(input.targetHint);
-    await this.debuggerCommand(selection.tabId, "Performance.enable", {});
-    const result = await this.debuggerCommand(
-      selection.tabId,
-      "Performance.getMetrics",
-      {}
-    );
-    const metrics = Array.isArray(result?.metrics) ? result.metrics.map((metric) => ({
-      name: metric.name,
-      value: metric.value
-    })) : [];
-    const output = { metrics, warnings: selection.warnings };
+    await this.enableConsole(selection.tabId);
+    const events = this.ensureDebugger().getConsoleEvents(selection.tabId);
+    const entries = events.map((event) => toConsoleEntry(event)).filter((entry) => entry !== null);
+    const result = {
+      entries,
+      warnings: selection.warnings
+    };
     this.markInspectConnected(input.sessionId);
-    return output;
+    return result;
   }
-  async screenshot(input) {
+  async networkHar(input) {
     this.requireSession(input.sessionId);
     const selection = await this.resolveTab(input.targetHint);
-    await this.debuggerCommand(selection.tabId, "Page.enable", {});
-    const format = input.format ?? "png";
-    let captureParams = {
-      format,
-      fromSurface: true
-    };
-    if (format !== "png" && typeof input.quality === "number") {
-      captureParams = { ...captureParams, quality: input.quality };
-    }
-    if (input.target === "full") {
-      const layout = await this.debuggerCommand(
-        selection.tabId,
-        "Page.getLayoutMetrics",
-        {}
-      );
-      const contentSize = layout?.contentSize;
-      if (contentSize) {
-        captureParams = {
-          ...captureParams,
-          clip: {
-            x: 0,
-            y: 0,
-            width: contentSize.width,
-            height: contentSize.height,
-            scale: 1
-          }
-        };
-      } else {
-        captureParams = { ...captureParams, captureBeyondViewport: true };
-      }
-    }
-    const result = await this.debuggerCommand(
-      selection.tabId,
-      "Page.captureScreenshot",
-      captureParams
-    );
-    const data = result.data;
-    if (!data) {
-      const error = new InspectError(
-        "INSPECT_UNAVAILABLE",
-        "Failed to capture screenshot.",
-        { retryable: false }
-      );
-      this.recordError(error);
-      throw error;
-    }
+    await this.enableNetwork(selection.tabId);
+    const events = this.ensureDebugger().getNetworkEvents(selection.tabId);
+    const har = buildHar(events, selection.tab.title);
     try {
       const rootDir = await ensureArtifactRootDir(input.sessionId);
       const artifactId = (0, import_crypto3.randomUUID)();
-      const extension = format === "jpeg" ? "jpg" : format;
-      const filePath = import_node_path2.default.join(
-        rootDir,
-        `screenshot-${artifactId}.${extension}`
-      );
-      await (0, import_promises2.writeFile)(filePath, Buffer.from(data, "base64"));
-      const mime = format === "jpeg" ? "image/jpeg" : `image/${format}`;
-      const output = {
+      const filePath = import_node_path2.default.join(rootDir, `har-${artifactId}.json`);
+      await (0, import_promises2.writeFile)(filePath, JSON.stringify(har, null, 2), "utf-8");
+      const result = {
         artifact_id: artifactId,
         path: filePath,
-        mime
+        mime: "application/json"
       };
       this.markInspectConnected(input.sessionId);
-      return output;
+      return result;
     } catch {
       const error = new InspectError(
         "ARTIFACT_IO_ERROR",
-        "Failed to write screenshot file."
-      );
-      this.recordError(error);
-      throw error;
-    }
-  }
-  ensureDebugger() {
-    if (!this.debugger) {
-      const error = this.buildUnavailableError();
-      this.recordError(error);
-      throw error;
-    }
-    return this.debugger;
-  }
-  async resolveTab(hint) {
-    if (!this.extensionBridge || !this.extensionBridge.isConnected()) {
-      const error = new InspectError(
-        "EXTENSION_DISCONNECTED",
-        "Extension is not connected.",
-        { retryable: true }
-      );
-      this.recordError(error);
-      throw error;
-    }
-    const tabs = this.extensionBridge.getStatus().tabs ?? [];
-    if (!Array.isArray(tabs) || tabs.length === 0) {
-      const error = new InspectError(
-        "TAB_NOT_FOUND",
-        "No tabs available to inspect."
-      );
-      this.recordError(error);
-      throw error;
-    }
-    const candidates = tabs.map((tab2) => ({
-      id: String(tab2.tab_id),
-      url: tab2.url ?? "",
-      title: tab2.title,
-      lastSeenAt: tab2.last_active_at ? Date.parse(tab2.last_active_at) : void 0
-    }));
-    const ranked = pickBestTarget(candidates, hint);
-    if (!ranked) {
-      const error = new InspectError("TAB_NOT_FOUND", "No matching tab found.");
-      this.recordError(error);
-      throw error;
-    }
-    const tabId = Number(ranked.candidate.id);
-    if (!Number.isFinite(tabId)) {
-      const error = new InspectError(
-        "TAB_NOT_FOUND",
-        "Resolved tab id is invalid."
+        "Failed to write HAR file."
       );
       this.recordError(error);
       throw error;
     }
-    const tab = tabs.find((entry) => entry.tab_id === tabId) ?? tabs[0];
-    const warnings = [];
-    if (!hint) {
-      warnings.push("No target hint provided; using the most recent tab.");
-    } else if (ranked.score < 20) {
-      warnings.push("Weak target match; using best available tab.");
-    }
-    return {
-      tabId,
-      tab,
-      warnings: warnings.length > 0 ? warnings : void 0
-    };
-  }
-  async enableConsole(tabId) {
-    await this.debuggerCommand(tabId, "Runtime.enable", {});
-    await this.debuggerCommand(tabId, "Log.enable", {});
-  }
-  async enableNetwork(tabId) {
-    await this.debuggerCommand(tabId, "Network.enable", {});
-  }
-  async enableAccessibility(tabId) {
-    await this.debuggerCommand(tabId, "Accessibility.enable", {});
-  }
-  recordSnapshot(sessionId, snapshot) {
-    const entries = this.collectSnapshotEntries(snapshot);
-    if (!entries) {
-      return;
-    }
-    this.snapshotHistory.push({
-      sessionId,
-      format: snapshot.format,
-      entries,
-      capturedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    let count = 0;
-    for (const record of this.snapshotHistory) {
-      if (record.sessionId === sessionId) {
-        count += 1;
-      }
-    }
-    while (count > this.maxSnapshotsPerSession) {
-      const index = this.snapshotHistory.findIndex(
-        (record) => record.sessionId === sessionId
-      );
-      if (index === -1) {
-        break;
-      }
-      this.snapshotHistory.splice(index, 1);
-      count -= 1;
-    }
-    while (this.snapshotHistory.length > this.maxSnapshotHistory) {
-      this.snapshotHistory.shift();
-    }
-  }
-  collectSnapshotEntries(snapshot) {
-    if (snapshot.format === "html" && typeof snapshot.snapshot === "string") {
-      return this.collectHtmlEntries(snapshot.snapshot);
-    }
-    if (snapshot.format === "ax") {
-      return this.collectAxEntries(snapshot.snapshot);
-    }
-    return null;
-  }
-  getAxNodes(snapshot) {
-    const nodes = Array.isArray(snapshot) ? snapshot : snapshot?.nodes;
-    return Array.isArray(nodes) ? nodes : [];
-  }
-  applyAxSnapshotFilters(snapshot, options) {
-    let filtered = snapshot;
-    if (options.compact) {
-      filtered = this.compactAxSnapshot(filtered);
-    }
-    if (options.interactiveOnly) {
-      filtered = this.filterAxSnapshot(
-        filtered,
-        (node) => this.isInteractiveAxNode(node)
-      );
-    }
-    return filtered;
   }
-  truncateAxSnapshot(snapshot, maxNodes) {
-    const nodes = this.getAxNodes(snapshot);
-    if (!Number.isFinite(maxNodes) || maxNodes <= 0) {
-      return { snapshot, truncated: false };
-    }
-    if (nodes.length === 0 || nodes.length <= maxNodes) {
-      return { snapshot, truncated: false };
-    }
-    const nodeById = /* @__PURE__ */ new Map();
-    const parentCount = /* @__PURE__ */ new Map();
-    for (const node of nodes) {
-      if (!node || typeof node !== "object" || typeof node.nodeId !== "string") {
-        continue;
-      }
-      nodeById.set(node.nodeId, node);
-      parentCount.set(node.nodeId, parentCount.get(node.nodeId) ?? 0);
-    }
-    if (nodeById.size === 0) {
-      const sliced = nodes.slice(0, maxNodes);
-      for (const node of sliced) {
-        if (node && typeof node === "object" && Array.isArray(node.childIds)) {
-          node.childIds = [];
-        }
-      }
-      return {
-        snapshot: this.replaceAxNodes(snapshot, sliced),
-        truncated: true
-      };
-    }
-    for (const node of nodes) {
-      if (!node || typeof node !== "object" || !Array.isArray(node.childIds)) {
-        continue;
-      }
-      for (const childId of node.childIds) {
-        if (typeof childId !== "string") {
-          continue;
-        }
-        parentCount.set(childId, (parentCount.get(childId) ?? 0) + 1);
-      }
-    }
-    let roots = Array.from(nodeById.keys()).filter(
-      (id) => (parentCount.get(id) ?? 0) === 0
-    );
-    if (roots.length === 0) {
-      const first = nodes.find(
-        (node) => node && typeof node.nodeId === "string"
-      )?.nodeId;
-      if (first) {
-        roots = [first];
-      }
-    }
-    const kept = /* @__PURE__ */ new Set();
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [...roots];
-    while (queue.length > 0 && kept.size < maxNodes) {
-      const id = queue.shift();
-      if (!id || visited.has(id)) {
-        continue;
-      }
-      visited.add(id);
-      const node = nodeById.get(id);
-      if (!node) {
-        continue;
-      }
-      kept.add(id);
-      if (Array.isArray(node.childIds)) {
-        for (const childId of node.childIds) {
-          if (typeof childId === "string" && !visited.has(childId)) {
-            queue.push(childId);
-          }
-        }
-      }
-    }
-    if (kept.size === 0) {
-      const fallback = [];
-      for (const node of nodes) {
-        if (fallback.length >= maxNodes) {
-          break;
-        }
-        if (node && typeof node.nodeId === "string") {
-          fallback.push(node.nodeId);
-        }
+  async evaluate(input) {
+    this.requireSession(input.sessionId);
+    const selection = await this.resolveTab(input.targetHint);
+    const expression = input.expression ?? "undefined";
+    await this.debuggerCommand(selection.tabId, "Runtime.enable", {});
+    const result = await this.debuggerCommand(
+      selection.tabId,
+      "Runtime.evaluate",
+      {
+        expression,
+        returnByValue: true,
+        awaitPromise: true
       }
-      fallback.forEach((id) => kept.add(id));
-    }
-    const filtered = nodes.filter(
-      (node) => node && typeof node.nodeId === "string" && kept.has(node.nodeId)
     );
-    for (const node of filtered) {
-      if (Array.isArray(node.childIds)) {
-        node.childIds = node.childIds.filter(
-          (id) => typeof id === "string" && kept.has(id)
-        );
-      }
+    if (result && typeof result === "object" && "exceptionDetails" in result) {
+      const output2 = {
+        exception: result.exceptionDetails,
+        warnings: selection.warnings
+      };
+      this.markInspectConnected(input.sessionId);
+      return output2;
     }
-    return {
-      snapshot: this.replaceAxNodes(snapshot, filtered),
-      truncated: true
+    const output = {
+      value: result?.result?.value,
+      warnings: selection.warnings
     };
+    this.markInspectConnected(input.sessionId);
+    return output;
   }
-  filterAxSnapshot(snapshot, predicate) {
-    const nodes = this.getAxNodes(snapshot);
-    if (nodes.length === 0) {
-      return snapshot;
-    }
-    const keepIds = /* @__PURE__ */ new Set();
-    const filtered = nodes.filter((node) => {
-      if (!node || typeof node !== "object") {
-        return false;
-      }
-      const keep = predicate(node);
-      if (keep && typeof node.nodeId === "string") {
-        keepIds.add(node.nodeId);
+  async extractContent(input) {
+    this.requireSession(input.sessionId);
+    const selection = await this.resolveTab(input.targetHint);
+    const debuggerCommand = this.debuggerCommand.bind(this);
+    const html = await captureHtml(selection.tabId, {
+      debuggerCommand,
+      onEvaluationFailed: () => {
+        const error = new InspectError(
+          "EVALUATION_FAILED",
+          "Failed to evaluate HTML snapshot.",
+          { retryable: false }
+        );
+        this.recordError(error);
+        throw error;
       }
-      return keep;
     });
-    for (const node of filtered) {
-      if (Array.isArray(node.childIds)) {
-        node.childIds = node.childIds.filter((id) => keepIds.has(id));
-      }
+    const url = selection.tab.url ?? "about:blank";
+    let article = null;
+    try {
+      const dom = new import_jsdom.JSDOM(html, { url });
+      const reader = new import_readability.Readability(dom.window.document);
+      article = reader.parse();
+    } catch {
+      const err = new InspectError(
+        "EVALUATION_FAILED",
+        "Failed to parse page content.",
+        { retryable: false }
+      );
+      this.recordError(err);
+      throw err;
     }
-    return this.replaceAxNodes(snapshot, filtered);
-  }
-  replaceAxNodes(snapshot, nodes) {
-    if (Array.isArray(snapshot)) {
-      return nodes;
+    if (!article) {
+      const err = new InspectError(
+        "NOT_SUPPORTED",
+        "Readability could not extract content.",
+        { retryable: false }
+      );
+      this.recordError(err);
+      throw err;
     }
-    if (snapshot && typeof snapshot === "object") {
-      snapshot.nodes = nodes;
+    let content = "";
+    if (input.format === "article_json") {
+      content = JSON.stringify(article, null, 2);
+    } else if (input.format === "text") {
+      content = article.textContent ?? "";
+    } else {
+      const turndown = new import_turndown.default();
+      content = turndown.turndown(article.content ?? "");
     }
-    return snapshot;
-  }
-  isInteractiveAxNode(node) {
-    const role = this.getAxRole(node);
-    return Boolean(role && INTERACTIVE_AX_ROLES.has(role));
+    const warnings = selection.warnings ?? [];
+    const includeMetadata = input.includeMetadata ?? true;
+    const output = {
+      content,
+      ...includeMetadata ? {
+        title: article.title ?? void 0,
+        byline: article.byline ?? void 0,
+        excerpt: article.excerpt ?? void 0,
+        siteName: article.siteName ?? void 0
+      } : {},
+      ...warnings.length > 0 ? { warnings } : {}
+    };
+    this.markInspectConnected(input.sessionId);
+    return output;
   }
-  compactAxSnapshot(snapshot) {
-    const nodes = this.getAxNodes(snapshot);
-    if (nodes.length === 0) {
-      return snapshot;
-    }
-    const nodeById = /* @__PURE__ */ new Map();
-    nodes.forEach((node) => {
-      if (node && typeof node.nodeId === "string") {
-        nodeById.set(node.nodeId, node);
-      }
-    });
-    const keepIds = /* @__PURE__ */ new Set();
-    for (const node of nodes) {
-      if (!node || typeof node !== "object" || typeof node.nodeId !== "string") {
-        continue;
-      }
-      if (this.shouldKeepCompactNode(node)) {
-        keepIds.add(node.nodeId);
+  async pageState(input) {
+    this.requireSession(input.sessionId);
+    const selection = await this.resolveTab(input.targetHint);
+    await this.debuggerCommand(selection.tabId, "Runtime.enable", {});
+    const expression = PAGE_STATE_SCRIPT;
+    const result = await this.debuggerCommand(
+      selection.tabId,
+      "Runtime.evaluate",
+      {
+        expression,
+        returnByValue: true,
+        awaitPromise: true
       }
-    }
-    const filtered = nodes.filter(
-      (node) => node && typeof node.nodeId === "string" && keepIds.has(node.nodeId)
     );
-    for (const node of filtered) {
-      if (!Array.isArray(node.childIds) || typeof node.nodeId !== "string") {
-        continue;
-      }
-      const nextChildIds = [];
-      for (const childId of node.childIds) {
-        nextChildIds.push(
-          ...this.collectKeptDescendants(childId, nodeById, keepIds)
-        );
-      }
-      node.childIds = Array.from(new Set(nextChildIds));
-    }
-    return this.replaceAxNodes(snapshot, filtered);
-  }
-  collectKeptDescendants(nodeId, nodeById, keepIds, visited = /* @__PURE__ */ new Set()) {
-    if (visited.has(nodeId)) {
-      return [];
-    }
-    visited.add(nodeId);
-    if (keepIds.has(nodeId)) {
-      return [nodeId];
-    }
-    const node = nodeById.get(nodeId);
-    if (!node || !Array.isArray(node.childIds)) {
-      return [];
-    }
-    const output = [];
-    for (const childId of node.childIds) {
-      output.push(
-        ...this.collectKeptDescendants(childId, nodeById, keepIds, visited)
+    if (result && typeof result === "object" && "exceptionDetails" in result) {
+      const error = new InspectError(
+        "EVALUATION_FAILED",
+        "Failed to capture page state.",
+        { retryable: false }
       );
+      this.recordError(error);
+      throw error;
     }
+    const value = result?.result?.value;
+    const raw = value && typeof value === "object" ? value : {};
+    const warnings = [
+      ...Array.isArray(raw.warnings) ? raw.warnings : [],
+      ...selection.warnings ?? []
+    ];
+    const output = {
+      forms: Array.isArray(raw.forms) ? raw.forms : [],
+      localStorage: Array.isArray(raw.localStorage) ? raw.localStorage : [],
+      sessionStorage: Array.isArray(raw.sessionStorage) ? raw.sessionStorage : [],
+      cookies: Array.isArray(raw.cookies) ? raw.cookies : [],
+      ...warnings.length > 0 ? { warnings } : {}
+    };
+    this.markInspectConnected(input.sessionId);
     return output;
   }
-  shouldKeepCompactNode(node) {
-    if (node.ignored) {
-      return false;
-    }
-    const role = this.getAxRole(node);
-    if (role && INTERACTIVE_AX_ROLES.has(role)) {
-      return true;
-    }
-    const name = this.getAxName(node);
-    const hasName = name.trim().length > 0;
-    const hasValue = this.hasAxValue(node);
-    if (hasName || hasValue) {
-      return true;
-    }
-    const hasChildren = Array.isArray(node.childIds) && node.childIds.length > 0;
-    if (!role || DECORATIVE_AX_ROLES.has(role)) {
-      return false;
-    }
-    return hasChildren;
-  }
-  getAxRole(node) {
-    const role = typeof node.role === "string" ? node.role : node.role?.value ?? "";
-    return typeof role === "string" ? role.toLowerCase() : "";
-  }
-  getAxName(node) {
-    const name = typeof node.name === "string" ? node.name : node.name?.value ?? "";
-    return typeof name === "string" ? name : "";
-  }
-  hasAxValue(node) {
-    if (!Array.isArray(node.properties)) {
-      return false;
-    }
-    for (const prop of node.properties) {
-      if (!prop || typeof prop !== "object") {
-        continue;
-      }
-      const value = prop.value?.value;
-      if (value === void 0 || value === null) {
-        continue;
-      }
-      if (typeof value === "string" && value.trim().length === 0) {
-        continue;
-      }
-      return true;
-    }
-    return false;
-  }
-  normalizeQuery(value) {
-    return value.trim().toLowerCase();
-  }
-  matchesTextValue(value, query) {
-    if (!query) {
-      return false;
-    }
-    return value.toLowerCase().includes(query);
-  }
-  matchesAxText(node, query) {
-    if (!query) {
-      return false;
-    }
-    const candidates = [this.getAxName(node)];
-    if (Array.isArray(node.properties)) {
-      for (const prop of node.properties) {
-        if (!prop || typeof prop !== "object") {
-          continue;
-        }
-        const value = prop.value?.value;
-        if (value === void 0 || value === null) {
-          continue;
-        }
-        if (typeof value === "string") {
-          candidates.push(value);
-        } else if (typeof value === "number" || typeof value === "boolean") {
-          candidates.push(String(value));
-        }
-      }
-    }
-    return candidates.some((text) => this.matchesTextValue(text, query));
-  }
-  collectHtmlEntries(html) {
-    const entries = /* @__PURE__ */ new Map();
-    const tagPattern = /<([a-zA-Z0-9-]+)([^>]*)>/g;
-    let match;
-    let index = 0;
-    while ((match = tagPattern.exec(html)) && entries.size < 1e3) {
-      const tag = match[1].toLowerCase();
-      const attrs = match[2] ?? "";
-      const idMatch = /\bid=["']([^"']+)["']/.exec(attrs);
-      const classMatch = /\bclass=["']([^"']+)["']/.exec(attrs);
-      const id = idMatch?.[1];
-      const className = classMatch?.[1]?.split(/\s+/)[0];
-      let key = tag;
-      if (id) {
-        key = `${tag}#${id}`;
-      } else if (className) {
-        key = `${tag}.${className}`;
-      } else {
-        key = `${tag}:nth-${index}`;
-      }
-      entries.set(key, attrs.trim());
-      index += 1;
-    }
-    return entries;
-  }
-  collectAxEntries(snapshot) {
-    const entries = /* @__PURE__ */ new Map();
-    const nodes = this.getAxNodes(snapshot);
-    if (nodes.length === 0) {
-      return entries;
-    }
-    nodes.forEach((node, index) => {
-      if (!node || typeof node !== "object") {
-        return;
-      }
-      const record = node;
-      const role = typeof record.role === "string" ? record.role : record.role?.value ?? "node";
-      const name = typeof record.name === "string" ? record.name : record.name?.value ?? "";
-      const nodeId = record.nodeId ?? (record.backendDOMNodeId !== void 0 ? String(record.backendDOMNodeId) : void 0);
-      const key = nodeId ? `node-${nodeId}` : `${role}:${name}:${index}`;
-      entries.set(key, `${role}:${name}`);
-    });
-    return entries;
+  async performanceMetrics(input) {
+    this.requireSession(input.sessionId);
+    const selection = await this.resolveTab(input.targetHint);
+    await this.debuggerCommand(selection.tabId, "Performance.enable", {});
+    const result = await this.debuggerCommand(
+      selection.tabId,
+      "Performance.getMetrics",
+      {}
+    );
+    const metrics = Array.isArray(result?.metrics) ? result.metrics.map((metric) => ({
+      name: metric.name,
+      value: metric.value
+    })) : [];
+    const output = { metrics, warnings: selection.warnings };
+    this.markInspectConnected(input.sessionId);
+    return output;
   }
-  assignRefsToAxSnapshot(snapshot) {
-    const nodes = this.getAxNodes(snapshot);
-    const refs = /* @__PURE__ */ new Map();
-    let index = 1;
-    for (const node of nodes) {
-      if (!node || typeof node !== "object") {
-        continue;
+  async screenshot(input) {
+    this.requireSession(input.sessionId);
+    const selection = await this.resolveTab(input.targetHint);
+    const format = input.format ?? "png";
+    const writeArtifact = async (data2) => {
+      try {
+        const rootDir = await ensureArtifactRootDir(input.sessionId);
+        const artifactId = (0, import_crypto3.randomUUID)();
+        const extension = format === "jpeg" ? "jpg" : format;
+        const filePath = import_node_path2.default.join(
+          rootDir,
+          `screenshot-${artifactId}.${extension}`
+        );
+        await (0, import_promises2.writeFile)(filePath, Buffer.from(data2, "base64"));
+        const mime = format === "jpeg" ? "image/jpeg" : `image/${format}`;
+        const output = {
+          artifact_id: artifactId,
+          path: filePath,
+          mime
+        };
+        this.markInspectConnected(input.sessionId);
+        return output;
+      } catch {
+        const error = new InspectError(
+          "ARTIFACT_IO_ERROR",
+          "Failed to write screenshot file."
+        );
+        this.recordError(error);
+        throw error;
       }
-      if (node.ignored) {
-        continue;
+    };
+    if (input.selector) {
+      if (!this.extensionBridge?.request) {
+        const error = new InspectError(
+          "NOT_SUPPORTED",
+          "Element screenshots require an extension that supports drive.screenshot."
+        );
+        this.recordError(error);
+        throw error;
       }
-      const backendId = node.backendDOMNodeId;
-      if (typeof backendId !== "number") {
-        continue;
+      const response = await this.extensionBridge.request(
+        "drive.screenshot",
+        {
+          tab_id: selection.tabId,
+          mode: "element",
+          selector: input.selector,
+          format,
+          ...typeof input.quality === "number" ? { quality: input.quality } : {}
+        },
+        12e4
+      );
+      if (response.status === "error") {
+        const error = new InspectError(
+          response.error?.code ?? "INSPECT_UNAVAILABLE",
+          response.error?.message ?? "Failed to capture element screenshot.",
+          {
+            retryable: response.error?.retryable ?? false,
+            ...response.error?.details ? { details: response.error.details } : {}
+          }
+        );
+        this.recordError(error);
+        throw error;
       }
-      const ref = `@e${index}`;
-      index += 1;
-      node.ref = ref;
-      refs.set(backendId, ref);
-    }
-    return refs;
-  }
-  async applySnapshotRefs(tabId, refs) {
-    const warnings = [];
-    await this.debuggerCommand(tabId, "DOM.enable", {});
-    await this.debuggerCommand(tabId, "Runtime.enable", {});
-    try {
-      await this.clearSnapshotRefs(tabId);
-    } catch {
-      warnings.push("Failed to clear prior snapshot refs.");
-    }
-    if (refs.size === 0) {
-      return warnings;
-    }
-    let applied = 0;
-    for (const [backendNodeId, ref] of refs) {
-      if (applied >= MAX_REF_ASSIGNMENTS) {
-        warnings.push(
-          `Snapshot refs truncated at ${MAX_REF_ASSIGNMENTS} elements.`
+      const result2 = response.result;
+      if (!result2?.data_base64 || typeof result2.data_base64 !== "string") {
+        const error = new InspectError(
+          "INSPECT_UNAVAILABLE",
+          "Failed to capture element screenshot."
         );
-        break;
+        this.recordError(error);
+        throw error;
       }
+      return await writeArtifact(result2.data_base64);
+    }
+    if (input.target === "full" && this.extensionBridge?.request) {
       try {
-        const described = await this.debuggerCommand(
-          tabId,
-          "DOM.describeNode",
+        const response = await this.extensionBridge.request(
+          "drive.screenshot",
           {
-            backendNodeId
-          }
+            tab_id: selection.tabId,
+            mode: "full_page",
+            format,
+            ...typeof input.quality === "number" ? { quality: input.quality } : {}
+          },
+          12e4
         );
-        const node = described.node;
-        if (!node || node.nodeType !== 1 || typeof node.nodeId !== "number") {
-          if (warnings.length < MAX_REF_WARNINGS) {
-            warnings.push(`Ref ${ref} could not be applied to a DOM element.`);
-          }
-          continue;
+        if (response.status === "error") {
+          const error = new InspectError(
+            response.error?.code ?? "INSPECT_UNAVAILABLE",
+            response.error?.message ?? "Failed to capture full page screenshot.",
+            {
+              retryable: response.error?.retryable ?? false,
+              ...response.error?.details ? { details: response.error.details } : {}
+            }
+          );
+          this.recordError(error);
+          throw error;
         }
-        await this.debuggerCommand(tabId, "DOM.setAttributeValue", {
-          nodeId: node.nodeId,
-          name: SNAPSHOT_REF_ATTRIBUTE,
-          value: ref
-        });
-        applied += 1;
-      } catch {
-        if (warnings.length < MAX_REF_WARNINGS) {
-          warnings.push(`Ref ${ref} could not be applied.`);
+        const result2 = response.result;
+        if (!result2?.data_base64 || typeof result2.data_base64 !== "string") {
+          const error = new InspectError(
+            "INSPECT_UNAVAILABLE",
+            "Failed to capture full page screenshot."
+          );
+          this.recordError(error);
+          throw error;
+        }
+        return await writeArtifact(result2.data_base64);
+      } catch (error) {
+        if (error instanceof InspectError) {
+          const code = String(error.code);
+          if (![
+            "NOT_SUPPORTED",
+            "NOT_IMPLEMENTED",
+            "INSPECT_UNAVAILABLE"
+          ].includes(code)) {
+            throw error;
+          }
         }
       }
     }
-    return warnings;
-  }
-  async clearSnapshotRefs(tabId) {
-    await this.debuggerCommand(tabId, "Runtime.evaluate", {
-      expression: `document.querySelectorAll('[${SNAPSHOT_REF_ATTRIBUTE}]').forEach((el) => el.removeAttribute('${SNAPSHOT_REF_ATTRIBUTE}'))`,
-      returnByValue: true,
-      awaitPromise: true
-    });
-  }
-  async resolveNodeIdForSelector(tabId, selector) {
-    await this.debuggerCommand(tabId, "DOM.enable", {});
-    const document = await this.debuggerCommand(tabId, "DOM.getDocument", {
-      depth: 1
-    });
-    const rootNodeId = document.root?.nodeId;
-    if (typeof rootNodeId !== "number") {
-      return { warnings: ["Failed to resolve DOM root for selector."] };
+    await this.debuggerCommand(selection.tabId, "Page.enable", {});
+    let captureParams = {
+      format,
+      fromSurface: true
+    };
+    if (format !== "png" && typeof input.quality === "number") {
+      captureParams = { ...captureParams, quality: input.quality };
     }
-    try {
-      const result = await this.debuggerCommand(tabId, "DOM.querySelector", {
-        nodeId: rootNodeId,
-        selector
-      });
-      const nodeId = result.nodeId;
-      if (!nodeId) {
-        return { warnings: [`Selector not found: ${selector}`] };
-      }
-      return { nodeId };
-    } catch (error) {
-      if (error instanceof InspectError) {
-        return { warnings: [error.message] };
+    if (input.target === "full") {
+      const layout = await this.debuggerCommand(
+        selection.tabId,
+        "Page.getLayoutMetrics",
+        {}
+      );
+      const contentSize = layout?.contentSize;
+      if (contentSize) {
+        captureParams = {
+          ...captureParams,
+          clip: {
+            x: 0,
+            y: 0,
+            width: contentSize.width,
+            height: contentSize.height,
+            scale: 1
+          }
+        };
+      } else {
+        captureParams = { ...captureParams, captureBeyondViewport: true };
       }
-      return { warnings: ["Selector query failed."] };
     }
-  }
-  async captureHtml(tabId, selector) {
-    await this.debuggerCommand(tabId, "Runtime.enable", {});
-    const expression = selector ? `(() => { try { const el = document.querySelector(${JSON.stringify(
-      selector
-    )}); return el ? el.outerHTML : ""; } catch { return ""; } })()` : "document.documentElement ? document.documentElement.outerHTML : ''";
-    const result = await this.debuggerCommand(tabId, "Runtime.evaluate", {
-      expression,
-      returnByValue: true,
-      awaitPromise: true
-    });
-    if (result && typeof result === "object" && "exceptionDetails" in result) {
+    const result = await this.debuggerCommand(
+      selection.tabId,
+      "Page.captureScreenshot",
+      captureParams
+    );
+    const data = result.data;
+    if (!data) {
       const error = new InspectError(
-        "EVALUATION_FAILED",
-        "Failed to evaluate HTML snapshot.",
+        "INSPECT_UNAVAILABLE",
+        "Failed to capture screenshot.",
         { retryable: false }
       );
       this.recordError(error);
       throw error;
     }
-    return String(
-      result?.result?.value ?? ""
-    );
+    return await writeArtifact(data);
+  }
+  ensureDebugger() {
+    if (!this.debugger) {
+      const error = this.buildUnavailableError();
+      this.recordError(error);
+      throw error;
+    }
+    return this.debugger;
+  }
+  async resolveTab(hint) {
+    if (!this.extensionBridge || !this.extensionBridge.isConnected()) {
+      const error = new InspectError(
+        "EXTENSION_DISCONNECTED",
+        "Extension is not connected.",
+        { retryable: true }
+      );
+      this.recordError(error);
+      throw error;
+    }
+    const tabs = this.extensionBridge.getStatus().tabs ?? [];
+    if (!Array.isArray(tabs) || tabs.length === 0) {
+      const error = new InspectError(
+        "TAB_NOT_FOUND",
+        "No tabs available to inspect."
+      );
+      this.recordError(error);
+      throw error;
+    }
+    const candidates = tabs.map((tab2) => ({
+      id: String(tab2.tab_id),
+      url: tab2.url ?? "",
+      title: tab2.title,
+      lastSeenAt: tab2.last_active_at ? Date.parse(tab2.last_active_at) : void 0
+    }));
+    const ranked = pickBestTarget(candidates, hint);
+    if (!ranked) {
+      const error = new InspectError("TAB_NOT_FOUND", "No matching tab found.");
+      this.recordError(error);
+      throw error;
+    }
+    const tabId = Number(ranked.candidate.id);
+    if (!Number.isFinite(tabId)) {
+      const error = new InspectError(
+        "TAB_NOT_FOUND",
+        "Resolved tab id is invalid."
+      );
+      this.recordError(error);
+      throw error;
+    }
+    const tab = tabs.find((entry) => entry.tab_id === tabId) ?? tabs[0];
+    const warnings = [];
+    if (!hint) {
+      warnings.push("No target hint provided; using the most recent tab.");
+    } else if (ranked.score < 20) {
+      warnings.push("Weak target match; using best available tab.");
+    }
+    return {
+      tabId,
+      tab,
+      warnings: warnings.length > 0 ? warnings : void 0
+    };
+  }
+  async enableConsole(tabId) {
+    await this.debuggerCommand(tabId, "Runtime.enable", {});
+    await this.debuggerCommand(tabId, "Log.enable", {});
+  }
+  async enableNetwork(tabId) {
+    await this.debuggerCommand(tabId, "Network.enable", {});
+  }
+  async enableAccessibility(tabId) {
+    await this.debuggerCommand(tabId, "Accessibility.enable", {});
   }
   async debuggerCommand(tabId, method, params, timeoutMs) {
     const debuggerBridge = this.ensureDebugger();
@@ -2323,319 +2792,6 @@ var InspectService = class {
       details: error.details
     });
   }
-  toConsoleEntry(event) {
-    const params = event.params ?? {};
-    switch (event.method) {
-      case "Runtime.consoleAPICalled": {
-        const rawArgs = Array.isArray(params.args) ? params.args : [];
-        const text = rawArgs.map((arg) => this.stringifyRemoteObject(arg)).join(" ");
-        const level = String(params.type ?? "log");
-        const stack = this.toStackFrames(
-          params.stackTrace
-        );
-        const args = rawArgs.map((arg) => this.toRemoteObjectSummary(arg)).filter(
-          (entry) => Boolean(entry)
-        );
-        return {
-          level,
-          text,
-          timestamp: event.timestamp,
-          ...stack && stack.length > 0 ? { stack } : {},
-          ...args.length > 0 ? { args } : {}
-        };
-      }
-      case "Runtime.exceptionThrown": {
-        const details = params.exceptionDetails;
-        const exception = this.toRemoteObjectSummary(details?.exception);
-        const stack = this.toStackFrames(details?.stackTrace);
-        const source = this.toSourceLocation({
-          url: details?.url,
-          lineNumber: details?.lineNumber,
-          columnNumber: details?.columnNumber
-        }) ?? // If the top frame exists, treat it as the source.
-        (stack && stack.length > 0 ? {
-          url: stack[0].url,
-          line: stack[0].line,
-          column: stack[0].column
-        } : void 0);
-        const baseText = typeof details?.text === "string" && details.text.trim().length > 0 ? details.text : "Uncaught exception";
-        const exceptionDesc = typeof exception?.description === "string" && exception.description.trim().length > 0 ? exception.description : void 0;
-        const text = baseText === "Uncaught" && exceptionDesc ? `Uncaught: ${exceptionDesc}` : baseText;
-        return {
-          level: "error",
-          text,
-          timestamp: event.timestamp,
-          ...source ? { source } : {},
-          ...stack && stack.length > 0 ? { stack } : {},
-          ...exception ? { exception } : {}
-        };
-      }
-      case "Log.entryAdded": {
-        const entry = params.entry;
-        if (!entry) {
-          return null;
-        }
-        const stack = this.toStackFrames(entry.stackTrace);
-        const source = this.toSourceLocation({
-          url: entry.url,
-          lineNumber: entry.lineNumber,
-          columnNumber: void 0
-        });
-        return {
-          level: entry.level ?? "log",
-          text: entry.text ?? "",
-          timestamp: event.timestamp,
-          ...source ? { source } : {},
-          ...stack && stack.length > 0 ? { stack } : {}
-        };
-      }
-      default:
-        return null;
-    }
-  }
-  toSourceLocation(input) {
-    const url = typeof input.url === "string" && input.url.length > 0 ? input.url : void 0;
-    const line = typeof input.lineNumber === "number" && Number.isFinite(input.lineNumber) ? Math.max(1, Math.floor(input.lineNumber) + 1) : void 0;
-    const column = typeof input.columnNumber === "number" && Number.isFinite(input.columnNumber) ? Math.max(1, Math.floor(input.columnNumber) + 1) : void 0;
-    if (!url && !line && !column) {
-      return void 0;
-    }
-    return {
-      ...url ? { url } : {},
-      ...line ? { line } : {},
-      ...column ? { column } : {}
-    };
-  }
-  toStackFrames(stackTrace) {
-    const frames = [];
-    const collect = (trace) => {
-      if (!trace || typeof trace !== "object") {
-        return;
-      }
-      const callFrames = trace.callFrames;
-      if (Array.isArray(callFrames)) {
-        for (const frame of callFrames) {
-          if (!frame || typeof frame !== "object") {
-            continue;
-          }
-          const functionName = typeof frame.functionName === "string" ? String(frame.functionName) : void 0;
-          const url = typeof frame.url === "string" ? String(frame.url) : void 0;
-          const lineNumber = frame.lineNumber;
-          const columnNumber = frame.columnNumber;
-          const loc = this.toSourceLocation({ url, lineNumber, columnNumber });
-          frames.push({
-            ...functionName ? { functionName } : {},
-            ...loc?.url ? { url: loc.url } : {},
-            ...loc?.line ? { line: loc.line } : {},
-            ...loc?.column ? { column: loc.column } : {}
-          });
-          if (frames.length >= 50) {
-            return;
-          }
-        }
-      }
-      const parent = trace.parent;
-      if (frames.length < 50 && parent) {
-        collect(parent);
-      }
-    };
-    collect(stackTrace);
-    return frames.length > 0 ? frames : void 0;
-  }
-  toRemoteObjectSummary(obj) {
-    if (!obj || typeof obj !== "object") {
-      return void 0;
-    }
-    const raw = obj;
-    const type = typeof raw.type === "string" ? raw.type : void 0;
-    const subtype = typeof raw.subtype === "string" ? raw.subtype : void 0;
-    const description = typeof raw.description === "string" ? raw.description : void 0;
-    const unserializableValue = typeof raw.unserializableValue === "string" ? raw.unserializableValue : void 0;
-    const out = {};
-    if (type) out.type = type;
-    if (subtype) out.subtype = subtype;
-    if (description) out.description = description;
-    if (raw.value !== void 0) out.value = raw.value;
-    if (unserializableValue) out.unserializableValue = unserializableValue;
-    return Object.keys(out).length > 0 ? out : void 0;
-  }
-  stringifyRemoteObject(value) {
-    if (!value || typeof value !== "object") {
-      return String(value ?? "");
-    }
-    const obj = value;
-    if (obj.unserializableValue) {
-      return obj.unserializableValue;
-    }
-    if (obj.value !== void 0) {
-      try {
-        return typeof obj.value === "string" ? obj.value : JSON.stringify(obj.value);
-      } catch {
-        return String(obj.value);
-      }
-    }
-    if (obj.description) {
-      return obj.description;
-    }
-    return obj.type ?? "";
-  }
-  buildHar(events, title) {
-    const requests = /* @__PURE__ */ new Map();
-    const toTimestamp = (event, fallback) => {
-      const raw = event.params?.wallTime;
-      if (typeof raw === "number") {
-        return raw * 1e3;
-      }
-      const ts = event.params?.timestamp;
-      if (typeof ts === "number") {
-        return ts * 1e3;
-      }
-      const parsed = Date.parse(event.timestamp);
-      if (Number.isFinite(parsed)) {
-        return parsed;
-      }
-      return fallback ?? Date.now();
-    };
-    for (const event of events) {
-      const params = event.params ?? {};
-      switch (event.method) {
-        case "Network.requestWillBeSent": {
-          const requestId = String(
-            params.requestId
-          );
-          if (!requestId) {
-            break;
-          }
-          const request = params.request;
-          const record = {
-            id: requestId,
-            url: request?.url,
-            method: request?.method,
-            requestHeaders: request?.headers ?? {},
-            startTime: toTimestamp(event)
-          };
-          requests.set(requestId, record);
-          break;
-        }
-        case "Network.responseReceived": {
-          const requestId = String(
-            params.requestId
-          );
-          if (!requestId) {
-            break;
-          }
-          const response = params.response;
-          const record = requests.get(requestId) ?? { id: requestId };
-          record.status = response?.status;
-          record.statusText = response?.statusText;
-          record.mimeType = response?.mimeType;
-          record.responseHeaders = response?.headers ?? {};
-          record.protocol = response?.protocol;
-          record.startTime = record.startTime ?? toTimestamp(event);
-          requests.set(requestId, record);
-          break;
-        }
-        case "Network.loadingFinished": {
-          const requestId = String(
-            params.requestId
-          );
-          if (!requestId) {
-            break;
-          }
-          const record = requests.get(requestId) ?? { id: requestId };
-          record.encodedDataLength = params.encodedDataLength;
-          record.endTime = toTimestamp(event, record.startTime);
-          requests.set(requestId, record);
-          break;
-        }
-        case "Network.loadingFailed": {
-          const requestId = String(
-            params.requestId
-          );
-          if (!requestId) {
-            break;
-          }
-          const record = requests.get(requestId) ?? { id: requestId };
-          record.endTime = toTimestamp(event, record.startTime);
-          requests.set(requestId, record);
-          break;
-        }
-        default:
-          break;
-      }
-    }
-    const entries = Array.from(requests.values()).map((record) => {
-      const started = record.startTime ?? Date.now();
-      const ended = record.endTime ?? started;
-      const time = Math.max(0, ended - started);
-      const url = record.url ?? "";
-      const queryString = [];
-      try {
-        const parsed = new URL(url);
-        parsed.searchParams.forEach((value, name) => {
-          queryString.push({ name, value });
-        });
-      } catch {
-      }
-      return {
-        pageref: "page_0",
-        startedDateTime: new Date(started).toISOString(),
-        time,
-        request: {
-          method: record.method ?? "GET",
-          url,
-          httpVersion: record.protocol ?? "HTTP/1.1",
-          cookies: [],
-          headers: [],
-          queryString,
-          headersSize: -1,
-          bodySize: -1
-        },
-        response: {
-          status: record.status ?? 0,
-          statusText: record.statusText ?? "",
-          httpVersion: record.protocol ?? "HTTP/1.1",
-          cookies: [],
-          headers: [],
-          redirectURL: "",
-          headersSize: -1,
-          bodySize: record.encodedDataLength ?? 0,
-          content: {
-            size: record.encodedDataLength ?? 0,
-            mimeType: record.mimeType ?? ""
-          }
-        },
-        cache: {},
-        timings: {
-          send: 0,
-          wait: time,
-          receive: 0
-        }
-      };
-    });
-    const startedDateTime = entries.length ? entries[0].startedDateTime : (/* @__PURE__ */ new Date()).toISOString();
-    return {
-      log: {
-        version: "1.2",
-        creator: {
-          name: "browser-bridge",
-          version: "0.0.0"
-        },
-        pages: [
-          {
-            id: "page_0",
-            title: title ?? "page",
-            startedDateTime,
-            pageTimings: {
-              onContentLoad: -1,
-              onLoad: -1
-            }
-          }
-        ],
-        entries
-      }
-    };
-  }
   markInspectConnected(sessionId) {
     try {
       const session = this.registry.require(sessionId);
@@ -2658,11 +2814,6 @@ var InspectService = class {
       { retryable: false }
     );
   }
-  throwUnavailable() {
-    const error = this.buildUnavailableError();
-    this.recordError(error);
-    throw error;
-  }
   requireSession(sessionId) {
     try {
       return this.registry.require(sessionId);
@@ -2797,6 +2948,11 @@ var DiagnosticReportSchema = import_zod2.z.object({
   ok: import_zod2.z.boolean(),
   session_id: import_zod2.z.string().optional(),
   checks: import_zod2.z.array(DiagnosticCheckSchema).optional(),
+  sessions: import_zod2.z.object({
+    count: import_zod2.z.number().finite().optional(),
+    max_age_ms: import_zod2.z.number().finite().optional(),
+    max_idle_ms: import_zod2.z.number().finite().optional()
+  }).optional(),
   extension: import_zod2.z.object({
     connected: import_zod2.z.boolean().optional(),
     version: import_zod2.z.string().optional(),
@@ -3203,10 +3359,30 @@ var ArtifactsScreenshotInputSchema = import_zod2.z.object({
   session_id: import_zod2.z.string().min(1),
   target: import_zod2.z.enum(["viewport", "full"]).default("viewport"),
   fullPage: import_zod2.z.boolean().default(false),
+  selector: import_zod2.z.string().min(1).optional(),
   format: import_zod2.z.enum(["png", "jpeg", "webp"]).default("png"),
   quality: import_zod2.z.number().min(0).max(100).optional()
 });
 var ArtifactsScreenshotOutputSchema = ArtifactInfoSchema;
+var HealthCheckInputSchema = import_zod2.z.object({});
+var HealthCheckOutputSchema = import_zod2.z.object({
+  started_at: import_zod2.z.string().min(1),
+  uptime_ms: import_zod2.z.number().finite().nonnegative(),
+  memory: import_zod2.z.object({
+    rss: import_zod2.z.number().finite().nonnegative(),
+    heapTotal: import_zod2.z.number().finite().nonnegative(),
+    heapUsed: import_zod2.z.number().finite().nonnegative(),
+    external: import_zod2.z.number().finite().nonnegative(),
+    arrayBuffers: import_zod2.z.number().finite().nonnegative().optional()
+  }).passthrough(),
+  sessions: import_zod2.z.object({
+    active: import_zod2.z.number().finite().nonnegative()
+  }).passthrough(),
+  extension: import_zod2.z.object({
+    connected: import_zod2.z.boolean(),
+    last_seen_at: import_zod2.z.string().min(1).optional()
+  }).passthrough()
+}).passthrough();
 var DiagnosticsDoctorInputSchema = import_zod2.z.object({
   session_id: import_zod2.z.string().min(1).optional()
 });
@@ -3262,6 +3438,7 @@ var registerArtifactsRoutes = (router, options = {}) => {
       const result = await inspect.screenshot({
         sessionId: input.session_id,
         target,
+        selector: input.selector,
         format: input.format,
         quality: input.quality,
         targetHint: hint
@@ -3362,6 +3539,11 @@ var buildDiagnosticReport = (sessionId, context = {}) => {
     ok: checks.every((check) => check.ok),
     session_id: sessionId,
     checks,
+    sessions: context.sessions ? {
+      count: context.sessions.count,
+      max_age_ms: context.sessions.maxAgeMs,
+      max_idle_ms: context.sessions.maxIdleMs
+    } : void 0,
     extension: {
       connected: extensionConnected,
       last_seen_at: context.extension?.lastSeenAt
@@ -3393,7 +3575,44 @@ var buildDiagnosticReport = (sessionId, context = {}) => {
 };
 
 // packages/core/src/routes/diagnostics.ts
+var PROCESS_STARTED_AT = new Date(
+  Date.now() - Math.floor(process.uptime() * 1e3)
+).toISOString();
 var registerDiagnosticsRoutes = (router, options = {}) => {
+  router.post("/health_check", (req, res) => {
+    const body = req.body ?? {};
+    if (!isRecord(body)) {
+      sendError(res, 400, {
+        code: "INVALID_ARGUMENT",
+        message: "Request body must be an object.",
+        retryable: false
+      });
+      return;
+    }
+    const parsed = HealthCheckInputSchema.safeParse(body);
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      sendError(res, 400, {
+        code: "INVALID_ARGUMENT",
+        message: issue?.message ?? "Invalid health check request.",
+        retryable: false,
+        details: issue?.path.length ? { field: issue.path.map((part) => String(part)).join(".") } : void 0
+      });
+      return;
+    }
+    const sessionsActive = options.registry ? options.registry.list().length : 0;
+    const extensionStatus = options.extensionBridge?.getStatus();
+    sendResult(res, {
+      started_at: PROCESS_STARTED_AT,
+      uptime_ms: Math.floor(process.uptime() * 1e3),
+      memory: process.memoryUsage(),
+      sessions: { active: sessionsActive },
+      extension: {
+        connected: extensionStatus?.connected ?? false,
+        ...extensionStatus?.lastSeenAt ? { last_seen_at: extensionStatus.lastSeenAt } : {}
+      }
+    });
+  });
   router.post("/diagnostics/doctor", (req, res) => {
     let sessionId;
     if (req.body !== void 0) {
@@ -3426,6 +3645,26 @@ var registerDiagnosticsRoutes = (router, options = {}) => {
         } catch {
         }
       }
+      if (options.registry) {
+        const now = Date.now();
+        const sessions = options.registry.list();
+        let maxAgeMs = 0;
+        let maxIdleMs = 0;
+        for (const session of sessions) {
+          const ageMs = now - session.createdAt.getTime();
+          const idleMs = now - session.lastAccessedAt.getTime();
+          if (ageMs > maxAgeMs) {
+            maxAgeMs = ageMs;
+          }
+          if (idleMs > maxIdleMs) {
+            maxIdleMs = idleMs;
+          }
+        }
+        context.sessions = {
+          count: sessions.length,
+          ...sessions.length > 0 ? { maxAgeMs, maxIdleMs } : {}
+        };
+      }
       if (options.extensionBridge) {
         const status = options.extensionBridge.getStatus();
         context.extension = {
@@ -4250,6 +4489,29 @@ var resolveCorePort = (portOverride) => {
   }
   return 3210;
 };
+var resolveSessionTtlMs = () => {
+  const env = process.env.BROWSER_BRIDGE_SESSION_TTL_MS || process.env.BROWSER_VISION_SESSION_TTL_MS;
+  if (env) {
+    const parsed = Number(env);
+    if (Number.isFinite(parsed) && parsed >= 0) {
+      return parsed;
+    }
+  }
+  return 60 * 60 * 1e3;
+};
+var resolveSessionCleanupIntervalMs = (ttlMs) => {
+  const env = process.env.BROWSER_BRIDGE_SESSION_CLEANUP_INTERVAL_MS || process.env.BROWSER_VISION_SESSION_CLEANUP_INTERVAL_MS;
+  if (env) {
+    const parsed = Number(env);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+    return 60 * 1e3;
+  }
+  return Math.min(60 * 1e3, Math.max(1e3, Math.floor(ttlMs / 2)));
+};
 var startCoreServer = (options = {}) => {
   const host = options.host ?? "127.0.0.1";
   const port = resolveCorePort(options.port);
@@ -4262,6 +4524,19 @@ var startCoreServer = (options = {}) => {
     server.listen(port, host, () => {
       const address = server.address();
       const resolvedPort = typeof address === "object" && address !== null ? address.port : port;
+      const ttlMs = resolveSessionTtlMs();
+      if (ttlMs > 0) {
+        const intervalMs = resolveSessionCleanupIntervalMs(ttlMs);
+        const timer = setInterval(() => {
+          try {
+            registry.cleanupIdleSessions(ttlMs);
+          } catch (error) {
+            console.warn("Session cleanup failed:", error);
+          }
+        }, intervalMs);
+        timer.unref();
+        server.on("close", () => clearInterval(timer));
+      }
       resolve({ app, registry, server, host, port: resolvedPort });
     });
     server.on("error", (error) => {
@@ -4702,6 +4977,16 @@ var TOOL_DEFINITIONS = [
       corePath: "/artifacts/screenshot"
     }
   },
+  {
+    name: "health_check",
+    config: {
+      title: "Health Check",
+      description: "Check server health including uptime, memory usage, active session count, and extension connection status.",
+      inputSchema: HealthCheckInputSchema,
+      outputSchema: envelope(HealthCheckOutputSchema),
+      corePath: "/health_check"
+    }
+  },
   {
     name: "diagnostics.doctor",
     config: {
@@ -4746,6 +5031,8 @@ var registerBrowserBridgeTools = (server, client) => {
 // packages/mcp-adapter/src/server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
 var DEFAULT_SERVER_NAME = "browser-bridge";
 var DEFAULT_SERVER_VERSION = "0.0.0";
 var createMcpServer = (options = {}) => {