@btraut/browser-bridge 0.1.0

package/dist/api.js

@@ -0,0 +1,4646 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/cli/src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  startCoreServer: () => startCoreServer,
+  startMcpServer: () => startMcpServer
+});
+module.exports = __toCommonJS(api_exports);
+
+// packages/core/src/server.ts
+var import_http = require("http");
+var import_express2 = __toESM(require("express"));
+
+// packages/core/src/routes/session.ts
+var import_express = require("express");
+
+// packages/core/src/state.ts
+var InvalidSessionTransition = class extends Error {
+  constructor(from, event) {
+    super(`Invalid session transition from ${from} via ${event}.`);
+    this.name = "InvalidSessionTransition";
+    this.from = from;
+    this.event = event;
+  }
+};
+var transitionSession = (state, event) => {
+  if (event === "CLOSE") {
+    return "CLOSED" /* CLOSED */;
+  }
+  if (event === "RECOVER_FAILED") {
+    if (state === "CLOSED" /* CLOSED */) {
+      throw new InvalidSessionTransition(state, event);
+    }
+    return "BROKEN" /* BROKEN */;
+  }
+  switch (state) {
+    case "INIT" /* INIT */: {
+      if (event === "DRIVE_CONNECTED") {
+        return "DRIVE_READY" /* DRIVE_READY */;
+      }
+      if (event === "INSPECT_CONNECTED") {
+        return "INSPECT_READY" /* INSPECT_READY */;
+      }
+      break;
+    }
+    case "DRIVE_READY" /* DRIVE_READY */: {
+      if (event === "INSPECT_CONNECTED") {
+        return "READY" /* READY */;
+      }
+      if (event === "DRIVE_DISCONNECTED") {
+        return "INIT" /* INIT */;
+      }
+      break;
+    }
+    case "INSPECT_READY" /* INSPECT_READY */: {
+      if (event === "DRIVE_CONNECTED") {
+        return "READY" /* READY */;
+      }
+      break;
+    }
+    case "READY" /* READY */: {
+      if (event === "DRIVE_DISCONNECTED") {
+        return "DEGRADED_DRIVE" /* DEGRADED_DRIVE */;
+      }
+      if (event === "INSPECT_DISCONNECTED") {
+        return "DEGRADED_INSPECT" /* DEGRADED_INSPECT */;
+      }
+      break;
+    }
+    case "DEGRADED_DRIVE" /* DEGRADED_DRIVE */: {
+      if (event === "RECOVER_SUCCEEDED") {
+        return "READY" /* READY */;
+      }
+      break;
+    }
+    case "DEGRADED_INSPECT" /* DEGRADED_INSPECT */: {
+      if (event === "RECOVER_SUCCEEDED") {
+        return "READY" /* READY */;
+      }
+      break;
+    }
+    case "BROKEN" /* BROKEN */:
+    case "CLOSED" /* CLOSED */:
+    default:
+      break;
+  }
+  throw new InvalidSessionTransition(state, event);
+};
+var shouldRetryDriveOp = (options) => {
+  return options.retryable && options.attempt === 0;
+};
+
+// packages/core/src/session.ts
+var import_crypto = require("crypto");
+var SessionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "SessionError";
+    this.code = code;
+  }
+};
+var SessionRegistry = class {
+  constructor() {
+    this.sessions = /* @__PURE__ */ new Map();
+  }
+  create() {
+    const now = /* @__PURE__ */ new Date();
+    const id = `session-${(0, import_crypto.randomUUID)()}`;
+    const session = {
+      id,
+      state: "INIT" /* INIT */,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.sessions.set(id, session);
+    return session;
+  }
+  get(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  list() {
+    return Array.from(this.sessions.values());
+  }
+  require(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new SessionError(
+        "SESSION_NOT_FOUND",
+        `Session ${sessionId} does not exist.`
+      );
+    }
+    return session;
+  }
+  apply(sessionId, event) {
+    const session = this.require(sessionId);
+    if (session.state === "CLOSED" /* CLOSED */ && event !== "CLOSE") {
+      throw new SessionError(
+        "SESSION_CLOSED",
+        `Session ${sessionId} is closed.`
+      );
+    }
+    try {
+      session.state = transitionSession(session.state, event);
+    } catch (error) {
+      if (error instanceof InvalidSessionTransition) {
+        throw error;
+      }
+      throw error;
+    }
+    session.updatedAt = /* @__PURE__ */ new Date();
+    return session;
+  }
+  recover(sessionId, outcome) {
+    const session = this.require(sessionId);
+    if (session.state === "CLOSED" /* CLOSED */) {
+      throw new SessionError(
+        "SESSION_CLOSED",
+        `Session ${sessionId} is closed.`
+      );
+    }
+    let recovered = false;
+    let message;
+    if (session.state === "DEGRADED_DRIVE" /* DEGRADED_DRIVE */ || session.state === "DEGRADED_INSPECT" /* DEGRADED_INSPECT */) {
+      if (outcome?.recovered) {
+        session.state = transitionSession(session.state, "RECOVER_SUCCEEDED");
+        recovered = true;
+        message = outcome.message ?? "Recovery succeeded.";
+      } else if (outcome) {
+        session.state = transitionSession(session.state, "RECOVER_FAILED");
+        recovered = false;
+        message = outcome.message ?? "Recovery failed.";
+      } else {
+        recovered = false;
+        message = "Recovery not attempted.";
+      }
+    } else if (session.state === "BROKEN" /* BROKEN */) {
+      recovered = false;
+      message = "Session is broken.";
+    } else {
+      recovered = false;
+      message = "No recovery needed.";
+    }
+    session.updatedAt = /* @__PURE__ */ new Date();
+    return {
+      sessionId: session.id,
+      recovered,
+      state: session.state,
+      message
+    };
+  }
+  close(sessionId) {
+    const session = this.require(sessionId);
+    session.state = transitionSession(session.state, "CLOSE");
+    session.updatedAt = /* @__PURE__ */ new Date();
+    return session;
+  }
+};
+
+// packages/core/src/routes/shared.ts
+var sendError = (res, status, error) => {
+  res.status(status).json({ ok: false, error });
+};
+var sendResult = (res, result) => {
+  res.status(200).json({ ok: true, result });
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var errorStatus = (code) => {
+  switch (code) {
+    case "INVALID_ARGUMENT":
+      return 400;
+    case "SESSION_NOT_FOUND":
+    case "TAB_NOT_FOUND":
+    case "LOCATOR_NOT_FOUND":
+      return 404;
+    case "SESSION_CLOSED":
+    case "FAILED_PRECONDITION":
+    case "DEBUGGER_IN_USE":
+      return 409;
+    case "ATTACH_DENIED":
+      return 403;
+    case "NOT_SUPPORTED":
+    case "NOT_IMPLEMENTED":
+      return 501;
+    case "EXTENSION_DISCONNECTED":
+    case "INSPECT_UNAVAILABLE":
+      return 503;
+    case "TIMEOUT":
+      return 504;
+    default:
+      return 500;
+  }
+};
+var deriveHintFromTabs = (tabs) => {
+  if (!Array.isArray(tabs) || tabs.length === 0) {
+    return void 0;
+  }
+  let best;
+  let bestTime = -Infinity;
+  for (const tab of tabs) {
+    const raw = tab.last_active_at;
+    const time = raw ? Date.parse(raw) : NaN;
+    const score = Number.isFinite(time) ? time : -Infinity;
+    if (!best || score > bestTime) {
+      best = tab;
+      bestTime = score;
+    }
+  }
+  if (!best) {
+    return void 0;
+  }
+  if (!best.url && !best.title && !best.last_active_at) {
+    return void 0;
+  }
+  return {
+    url: best.url,
+    title: best.title,
+    lastActiveAt: best.last_active_at
+  };
+};
+
+// packages/core/src/routes/session.ts
+var readSessionId = (body) => {
+  if (!isRecord(body)) {
+    return void 0;
+  }
+  const sessionId = body.session_id;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    return void 0;
+  }
+  return sessionId;
+};
+var createSessionRouter = (registry, options = {}) => {
+  const router = (0, import_express.Router)();
+  router.post("/create", (req, res) => {
+    const body = req.body;
+    if (body !== void 0) {
+      if (!isRecord(body)) {
+        return sendError(res, 400, {
+          code: "INVALID_ARGUMENT",
+          message: "Request body must be an object.",
+          retryable: false
+        });
+      }
+      if (Object.keys(body).length > 0) {
+        return sendError(res, 400, {
+          code: "INVALID_ARGUMENT",
+          message: "session.create does not accept any input fields.",
+          retryable: false
+        });
+      }
+    }
+    const session = registry.create();
+    if (options.driveConnected?.()) {
+      try {
+        registry.apply(session.id, "DRIVE_CONNECTED");
+      } catch {
+      }
+    }
+    return sendResult(res, {
+      session_id: session.id,
+      state: session.state,
+      created_at: session.createdAt.toISOString()
+    });
+  });
+  router.post("/status", (req, res) => {
+    const sessionId = readSessionId(req.body);
+    if (!sessionId) {
+      return sendError(res, 400, {
+        code: "INVALID_ARGUMENT",
+        message: "session_id is required",
+        retryable: false
+      });
+    }
+    try {
+      const session = registry.require(sessionId);
+      return sendResult(res, {
+        session_id: session.id,
+        state: session.state,
+        updated_at: session.updatedAt.toISOString()
+      });
+    } catch (error) {
+      if (error instanceof SessionError) {
+        return sendError(res, 404, {
+          code: error.code,
+          message: error.message,
+          retryable: false
+        });
+      }
+      return sendError(res, 500, {
+        code: "INTERNAL",
+        message: "Unexpected error while fetching status.",
+        retryable: false
+      });
+    }
+  });
+  router.post("/recover", async (req, res) => {
+    const sessionId = readSessionId(req.body);
+    if (!sessionId) {
+      return sendError(res, 400, {
+        code: "INVALID_ARGUMENT",
+        message: "session_id is required",
+        retryable: false
+      });
+    }
+    try {
+      const session = registry.require(sessionId);
+      let outcome;
+      if (session.state === "DEGRADED_DRIVE" /* DEGRADED_DRIVE */) {
+        const connected = options.driveConnected?.() ?? false;
+        outcome = {
+          recovered: connected,
+          message: connected ? "Drive recovery succeeded." : "Drive recovery failed."
+        };
+      } else if (session.state === "DEGRADED_INSPECT" /* DEGRADED_INSPECT */) {
+        const recovered = options.inspectRecover ? await options.inspectRecover(sessionId) : false;
+        outcome = {
+          recovered,
+          message: recovered ? "Inspect recovery succeeded." : "Inspect recovery failed."
+        };
+      }
+      const result = registry.recover(sessionId, outcome);
+      if (outcome) {
+        const attempt = {
+          sessionId,
+          recovered: result.recovered,
+          state: result.state,
+          message: result.message,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        options.recordRecovery?.(attempt);
+        const status = result.recovered ? "succeeded" : "failed";
+        console.info(
+          `[recovery] session ${sessionId} ${status}: ${result.message ?? ""}`
+        );
+      }
+      return sendResult(res, {
+        session_id: result.sessionId,
+        recovered: result.recovered,
+        state: result.state,
+        message: result.message
+      });
+    } catch (error) {
+      if (error instanceof SessionError) {
+        const status = error.code === "SESSION_CLOSED" ? 409 : 404;
+        return sendError(res, status, {
+          code: error.code,
+          message: error.message,
+          retryable: false
+        });
+      }
+      if (error instanceof InvalidSessionTransition) {
+        return sendError(res, 409, {
+          code: "FAILED_PRECONDITION",
+          message: error.message,
+          retryable: false
+        });
+      }
+      return sendError(res, 500, {
+        code: "INTERNAL",
+        message: "Unexpected error while recovering session.",
+        retryable: false
+      });
+    }
+  });
+  router.post("/close", (req, res) => {
+    const sessionId = readSessionId(req.body);
+    if (!sessionId) {
+      return sendError(res, 400, {
+        code: "INVALID_ARGUMENT",
+        message: "session_id is required",
+        retryable: false
+      });
+    }
+    try {
+      registry.close(sessionId);
+      return sendResult(res, { ok: true });
+    } catch (error) {
+      if (error instanceof SessionError) {
+        return sendError(res, 404, {
+          code: error.code,
+          message: error.message,
+          retryable: false
+        });
+      }
+      if (error instanceof InvalidSessionTransition) {
+        return sendError(res, 409, {
+          code: "FAILED_PRECONDITION",
+          message: error.message,
+          retryable: false
+        });
+      }
+      return sendError(res, 500, {
+        code: "INTERNAL",
+        message: "Unexpected error while closing session.",
+        retryable: false
+      });
+    }
+  });
+  return router;
+};
+
+// packages/core/src/inspect.ts
+var import_crypto3 = require("crypto");
+var import_promises2 = require("node:fs/promises");
+var import_node_path2 = __toESM(require("node:path"));
+var import_readability = require("@mozilla/readability");
+var import_jsdom = require("jsdom");
+var import_turndown = __toESM(require("turndown"));
+
+// packages/core/src/artifacts.ts
+var import_promises = require("node:fs/promises");
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var ARTIFACTS_DIR_NAME = "browser-agent";
+var resolveTempRoot = () => process.env.TMPDIR || process.env.TEMP || process.env.TMP || import_node_os.default.tmpdir();
+var getArtifactRootDir = (sessionId) => import_node_path.default.join(resolveTempRoot(), ARTIFACTS_DIR_NAME, sessionId);
+var ensureArtifactRootDir = async (sessionId) => {
+  const rootDir = getArtifactRootDir(sessionId);
+  await (0, import_promises.mkdir)(rootDir, { recursive: true });
+  return rootDir;
+};
+
+// packages/core/src/extension-bridge.ts
+var import_crypto2 = require("crypto");
+var import_ws = require("ws");
+var ExtensionBridgeError = class extends Error {
+  constructor(code, message, retryable = false, details) {
+    super(message);
+    this.name = "ExtensionBridgeError";
+    this.code = code;
+    this.retryable = retryable;
+    this.details = details;
+  }
+};
+var ExtensionBridge = class {
+  constructor(options = {}) {
+    this.socket = null;
+    this.pending = /* @__PURE__ */ new Map();
+    this.connected = false;
+    this.tabs = [];
+    this.heartbeatInterval = null;
+    this.awaitingHeartbeat = false;
+    this.debuggerListeners = /* @__PURE__ */ new Set();
+    this.wss = new import_ws.WebSocketServer({ noServer: true });
+    this.path = options.path ?? "/drive";
+    this.registry = options.registry;
+    this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? 15e3;
+    this.heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? 5e3;
+    this.wss.on("connection", (socket) => {
+      this.handleConnection(socket);
+    });
+  }
+  attach(server) {
+    server.on("upgrade", (request, socket, head) => {
+      const url = new URL(request.url ?? "", "ws://127.0.0.1");
+      if (url.pathname !== this.path) {
+        socket.destroy();
+        return;
+      }
+      this.wss.handleUpgrade(request, socket, head, (ws) => {
+        this.wss.emit("connection", ws, request);
+      });
+    });
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStatus() {
+    return {
+      connected: this.connected,
+      lastSeenAt: this.lastSeenAt,
+      tabs: this.tabs
+    };
+  }
+  async request(action, params, timeoutMs = 3e4) {
+    const response = await this.requestInternal(action, params, timeoutMs);
+    return response;
+  }
+  async requestDebugger(action, params, timeoutMs = 3e4) {
+    const response = await this.requestInternal(action, params, timeoutMs);
+    return response;
+  }
+  onDebuggerEvent(listener) {
+    this.debuggerListeners.add(listener);
+    return () => {
+      this.debuggerListeners.delete(listener);
+    };
+  }
+  async requestInternal(action, params, timeoutMs = 3e4) {
+    if (!this.socket || this.socket.readyState !== import_ws.WebSocket.OPEN) {
+      throw new ExtensionBridgeError(
+        "EXTENSION_DISCONNECTED",
+        "Extension is not connected.",
+        true
+      );
+    }
+    const id = (0, import_crypto2.randomUUID)();
+    const request = typeof action === "string" && action.startsWith("debugger.") ? {
+      id,
+      action,
+      status: "request",
+      params
+    } : {
+      id,
+      action,
+      status: "request",
+      params
+    };
+    const response = await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new ExtensionBridgeError(
+            "TIMEOUT",
+            `Extension request timed out after ${timeoutMs}ms.`,
+            true,
+            { action }
+          )
+        );
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve,
+        reject,
+        timeout
+      });
+      this.socket?.send(JSON.stringify(request));
+    });
+    return response;
+  }
+  startHeartbeat() {
+    if (this.heartbeatInterval) {
+      return;
+    }
+    this.heartbeatInterval = setInterval(() => {
+      void this.sendHeartbeat();
+    }, this.heartbeatIntervalMs);
+    void this.sendHeartbeat();
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    this.awaitingHeartbeat = false;
+  }
+  async sendHeartbeat() {
+    if (!this.socket || this.socket.readyState !== import_ws.WebSocket.OPEN) {
+      return;
+    }
+    if (this.awaitingHeartbeat) {
+      return;
+    }
+    this.awaitingHeartbeat = true;
+    try {
+      await this.requestInternal(
+        "drive.ping",
+        void 0,
+        this.heartbeatTimeoutMs
+      );
+    } catch (error) {
+      console.warn("Extension heartbeat failed:", error);
+      this.forceDisconnect();
+    } finally {
+      this.awaitingHeartbeat = false;
+    }
+  }
+  forceDisconnect() {
+    if (this.socket && this.socket.readyState === import_ws.WebSocket.OPEN) {
+      try {
+        this.socket.terminate();
+      } catch {
+        this.socket.close();
+      }
+    }
+    this.handleDisconnect();
+  }
+  handleConnection(socket) {
+    if (this.socket && this.socket.readyState === import_ws.WebSocket.OPEN) {
+      this.socket.close();
+    }
+    this.socket = socket;
+    this.connected = true;
+    this.lastSeenAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.applyDriveConnected();
+    this.startHeartbeat();
+    socket.on("message", (data) => {
+      this.handleMessage(data);
+    });
+    socket.on("close", () => {
+      this.handleDisconnect();
+    });
+    socket.on("error", () => {
+      this.handleDisconnect();
+    });
+  }
+  handleDisconnect() {
+    if (!this.connected) {
+      return;
+    }
+    this.stopHeartbeat();
+    this.connected = false;
+    this.socket = null;
+    this.lastSeenAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.applyDriveDisconnected();
+    for (const [id, pending] of this.pending.entries()) {
+      clearTimeout(pending.timeout);
+      pending.reject(
+        new ExtensionBridgeError(
+          "EXTENSION_DISCONNECTED",
+          "Extension disconnected before responding.",
+          true,
+          { request_id: id }
+        )
+      );
+      this.pending.delete(id);
+    }
+  }
+  handleMessage(data) {
+    const text = typeof data === "string" ? data : data.toString();
+    let message = null;
+    try {
+      message = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!message || typeof message !== "object") {
+      return;
+    }
+    this.lastSeenAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (message.status === "event") {
+      this.handleEvent(message);
+      return;
+    }
+    if (message.status === "ok" || message.status === "error" || message.status === "ack") {
+      const pending = this.pending.get(message.id);
+      if (!pending) {
+        return;
+      }
+      clearTimeout(pending.timeout);
+      this.pending.delete(message.id);
+      pending.resolve(message);
+    }
+  }
+  handleEvent(message) {
+    if (message.action === "drive.hello" || message.action === "drive.tab_report") {
+      const tabs = message.params?.tabs;
+      if (Array.isArray(tabs)) {
+        this.tabs = tabs;
+      }
+    }
+    if (typeof message.action === "string" && message.action.startsWith("debugger.")) {
+      this.emitDebuggerEvent(message);
+    }
+  }
+  emitDebuggerEvent(event) {
+    for (const listener of this.debuggerListeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.debug("Debugger event listener failed.", error);
+      }
+    }
+  }
+  applyDriveConnected() {
+    if (!this.registry) {
+      return;
+    }
+    for (const session of this.registry.list()) {
+      try {
+        if (session.state === "INIT" /* INIT */) {
+          this.registry.apply(session.id, "DRIVE_CONNECTED");
+        } else if (session.state === "INSPECT_READY" /* INSPECT_READY */) {
+          this.registry.apply(session.id, "DRIVE_CONNECTED");
+        } else if (session.state === "DEGRADED_DRIVE" /* DEGRADED_DRIVE */) {
+          this.registry.apply(session.id, "RECOVER_SUCCEEDED");
+        }
+      } catch (error) {
+        console.debug(
+          `Drive connect transition ignored for session ${session.id} (${session.state}).`,
+          error
+        );
+      }
+    }
+  }
+  applyDriveDisconnected() {
+    if (!this.registry) {
+      return;
+    }
+    for (const session of this.registry.list()) {
+      try {
+        if (session.state === "READY" /* READY */) {
+          this.registry.apply(session.id, "DRIVE_DISCONNECTED");
+        }
+      } catch (error) {
+        console.debug(
+          `Drive disconnect transition ignored for session ${session.id} (${session.state}).`,
+          error
+        );
+      }
+    }
+  }
+};
+var toDriveError = (error) => ({
+  code: error.code,
+  message: error.message,
+  retryable: error.retryable,
+  ...error.details ? { details: error.details } : {}
+});
+
+// packages/core/src/drive.ts
+var DriveMutex = class {
+  constructor() {
+    this.tail = Promise.resolve();
+  }
+  async runExclusive(work) {
+    const result = this.tail.then(work, work);
+    this.tail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return await result;
+  }
+};
+var driveMutex = new DriveMutex();
+var DriveController = class {
+  constructor(bridge, registry) {
+    this.bridge = bridge;
+    this.registry = registry;
+  }
+  getLastError() {
+    if (!this.lastError || !this.lastErrorAt) {
+      return void 0;
+    }
+    return { error: this.lastError, at: this.lastErrorAt };
+  }
+  recordError(error) {
+    this.lastError = error;
+    this.lastErrorAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  async execute(sessionId, action, params, timeoutMs) {
+    return await driveMutex.runExclusive(async () => {
+      try {
+        this.registry.require(sessionId);
+      } catch (error) {
+        if (error instanceof SessionError) {
+          const errorInfo2 = {
+            code: error.code,
+            message: error.message,
+            retryable: false
+          };
+          this.recordError(errorInfo2);
+          return {
+            ok: false,
+            error: errorInfo2
+          };
+        }
+        const errorInfo = {
+          code: "INTERNAL",
+          message: "Unexpected error while validating session.",
+          retryable: false
+        };
+        this.recordError(errorInfo);
+        return {
+          ok: false,
+          error: errorInfo
+        };
+      }
+      if (this.bridge.isConnected()) {
+        this.ensureDriveReady(sessionId);
+      }
+      let attempt = 0;
+      while (true) {
+        try {
+          const response = await this.bridge.request(
+            action,
+            params,
+            timeoutMs
+          );
+          if (response.status === "ok") {
+            return {
+              ok: true,
+              result: response.result
+            };
+          }
+          const errorInfo = response.error ?? {
+            code: "UNKNOWN",
+            message: "Drive operation failed.",
+            retryable: false
+          };
+          if (shouldRetryDriveOp({ attempt, retryable: errorInfo.retryable })) {
+            attempt += 1;
+            continue;
+          }
+          this.recordError(errorInfo);
+          return { ok: false, error: errorInfo };
+        } catch (error) {
+          if (error instanceof ExtensionBridgeError) {
+            if (error.code === "EXTENSION_DISCONNECTED") {
+              this.applyDriveDisconnected(sessionId);
+            }
+            const errorInfo2 = toDriveError(error);
+            if (shouldRetryDriveOp({ attempt, retryable: errorInfo2.retryable })) {
+              attempt += 1;
+              continue;
+            }
+            this.recordError(errorInfo2);
+            return { ok: false, error: errorInfo2 };
+          }
+          const errorInfo = {
+            code: "INTERNAL",
+            message: "Unexpected error while executing drive action.",
+            retryable: false
+          };
+          this.recordError(errorInfo);
+          return {
+            ok: false,
+            error: errorInfo
+          };
+        }
+      }
+    });
+  }
+  ensureDriveReady(sessionId) {
+    try {
+      const session = this.registry.require(sessionId);
+      if (session.state === "INIT" /* INIT */) {
+        this.registry.apply(sessionId, "DRIVE_CONNECTED");
+      } else if (session.state === "INSPECT_READY" /* INSPECT_READY */) {
+        this.registry.apply(sessionId, "DRIVE_CONNECTED");
+      } else if (session.state === "DEGRADED_DRIVE" /* DEGRADED_DRIVE */) {
+        this.registry.apply(sessionId, "RECOVER_SUCCEEDED");
+      }
+    } catch (error) {
+      console.debug(
+        `Drive ready transition ignored for session ${sessionId}.`,
+        error
+      );
+    }
+  }
+  applyDriveDisconnected(sessionId) {
+    try {
+      const session = this.registry.require(sessionId);
+      if (session.state === "READY" /* READY */) {
+        this.registry.apply(sessionId, "DRIVE_DISCONNECTED");
+      }
+    } catch (error) {
+      console.debug(
+        `Drive disconnect transition ignored for session ${sessionId}.`,
+        error
+      );
+    }
+  }
+};
+
+// 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;
+var INTERACTIVE_AX_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "textbox",
+  "combobox",
+  "listbox",
+  "checkbox",
+  "radio",
+  "switch",
+  "searchbox",
+  "spinbutton",
+  "slider",
+  "option"
+]);
+var DECORATIVE_AX_ROLES = /* @__PURE__ */ new Set(["generic", "none", "presentation"]);
+var LABEL_AX_ROLES = /* @__PURE__ */ new Set([
+  "textbox",
+  "combobox",
+  "listbox",
+  "checkbox",
+  "radio",
+  "switch",
+  "searchbox",
+  "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;
+  }
+  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",
+          debuggerError.error.message,
+          {
+            retryable: debuggerError.error.retryable,
+            details: {
+              code: debuggerError.error.code,
+              ...debuggerError.error.details ? debuggerError.error.details : {}
+            }
+          }
+        ),
+        at: debuggerError.at
+      };
+    }
+    return { error: this.lastError, at: this.lastErrorAt };
+  }
+  async reconnect(sessionId) {
+    try {
+      this.requireSession(sessionId);
+      const selection = await this.resolveTab();
+      const debuggerBridge = this.ensureDebugger();
+      const result = await debuggerBridge.attach(selection.tabId);
+      if (result.ok) {
+        this.markInspectConnected(sessionId);
+        return true;
+      }
+      const error = this.mapDebuggerError(result.error);
+      this.recordError(error);
+      return false;
+    } catch (error) {
+      if (error instanceof InspectError) {
+        this.recordError(error);
+      }
+      return false;
+    }
+  }
+  async domSnapshot(input) {
+    this.requireSession(input.sessionId);
+    const selection = await this.resolveTab(input.targetHint);
+    const work = async () => {
+      if (input.format === "html") {
+        const html = await this.captureHtml(selection.tabId, input.selector);
+        const warnings = [...selection.warnings ?? []];
+        if (input.interactive) {
+          warnings.push(
+            "Interactive filter is only supported for AX snapshots."
+          );
+        }
+        if (input.compact) {
+          warnings.push("Compact filter is only supported for AX snapshots.");
+        }
+        if (input.selector && html === "") {
+          warnings.push(`Selector not found: ${input.selector}`);
+        }
+        return {
+          format: "html",
+          snapshot: html,
+          ...warnings.length > 0 ? { warnings } : {}
+        };
+      }
+      try {
+        await this.enableAccessibility(selection.tabId);
+        const selectorWarnings = [];
+        let result2;
+        if (input.selector) {
+          const resolved = await this.resolveNodeIdForSelector(
+            selection.tabId,
+            input.selector
+          );
+          selectorWarnings.push(...resolved.warnings ?? []);
+          if (!resolved.nodeId) {
+            let refWarnings2 = [];
+            try {
+              refWarnings2 = await this.applySnapshotRefs(
+                selection.tabId,
+                /* @__PURE__ */ new Map()
+              );
+            } catch {
+              refWarnings2 = ["Failed to clear prior snapshot refs."];
+            }
+            const warnings2 = [
+              ...selection.warnings ?? [],
+              ...selectorWarnings,
+              ...refWarnings2
+            ];
+            return {
+              format: "ax",
+              snapshot: { nodes: [] },
+              ...warnings2.length > 0 ? { warnings: warnings2 } : {}
+            };
+          }
+          result2 = await this.debuggerCommand(
+            selection.tabId,
+            "Accessibility.getPartialAXTree",
+            { nodeId: resolved.nodeId }
+          );
+        } else {
+          result2 = await this.debuggerCommand(
+            selection.tabId,
+            "Accessibility.getFullAXTree",
+            {}
+          );
+        }
+        const snapshot = input.interactive || input.compact ? this.applyAxSnapshotFilters(result2, {
+          interactiveOnly: input.interactive,
+          compact: input.compact
+        }) : result2;
+        const refMap = this.assignRefsToAxSnapshot(snapshot);
+        const refWarnings = await this.applySnapshotRefs(
+          selection.tabId,
+          refMap
+        );
+        const warnings = [
+          ...selection.warnings ?? [],
+          ...selectorWarnings,
+          ...refWarnings ?? []
+        ];
+        return {
+          format: "ax",
+          snapshot,
+          ...warnings.length > 0 ? { warnings } : {}
+        };
+      } catch (error) {
+        if (error instanceof InspectError) {
+          const fallbackCodes = [
+            "NOT_SUPPORTED",
+            "INSPECT_UNAVAILABLE",
+            "EVALUATION_FAILED"
+          ];
+          if (!fallbackCodes.includes(error.code)) {
+            throw error;
+          }
+          const html = await this.captureHtml(selection.tabId, input.selector);
+          const warnings = [
+            ...selection.warnings ?? [],
+            "AX snapshot failed; returned HTML instead.",
+            ...input.interactive ? ["Interactive filter is only supported for AX snapshots."] : [],
+            ...input.compact ? ["Compact filter is only supported for AX snapshots."] : [],
+            ...input.selector && html === "" ? [`Selector not found: ${input.selector}`] : []
+          ];
+          return {
+            format: "html",
+            snapshot: html,
+            warnings
+          };
+        }
+        throw error;
+      }
+    };
+    if (input.consistency === "quiesce") {
+      const result2 = await driveMutex.runExclusive(work);
+      this.recordSnapshot(input.sessionId, result2);
+      this.markInspectConnected(input.sessionId);
+      return result2;
+    }
+    const result = await work();
+    this.recordSnapshot(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}.`
+    };
+  }
+  async find(input) {
+    const snapshot = await this.domSnapshot({
+      sessionId: input.sessionId,
+      format: "ax",
+      consistency: "best_effort",
+      targetHint: input.targetHint
+    });
+    const warnings = [...snapshot.warnings ?? []];
+    if (snapshot.format !== "ax") {
+      warnings.push("AX snapshot unavailable; cannot resolve refs.");
+      return {
+        matches: [],
+        ...warnings.length > 0 ? { warnings } : {}
+      };
+    }
+    const nodes = this.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) : "";
+    for (const node of nodes) {
+      if (!node || typeof node !== "object") {
+        continue;
+      }
+      if (typeof node.ref !== "string" || node.ref.length === 0) {
+        continue;
+      }
+      const role = this.getAxRole(node);
+      const name = this.getAxName(node);
+      if (input.kind === "role") {
+        if (!role || role !== roleQuery) {
+          continue;
+        }
+        if (nameQuery && !this.matchesTextValue(name, nameQuery)) {
+          continue;
+        }
+      } else if (input.kind === "text") {
+        if (!textQuery || !this.matchesAxText(node, textQuery)) {
+          continue;
+        }
+      } else if (input.kind === "label") {
+        if (!labelQuery || !LABEL_AX_ROLES.has(role)) {
+          continue;
+        }
+        if (!this.matchesTextValue(name, labelQuery)) {
+          continue;
+        }
+      }
+      matches.push({
+        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 : [],
+      ...warnings.length > 0 ? { warnings } : {}
+    };
+    this.markInspectConnected(input.sessionId);
+    return output;
+  }
+  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;
+  }
+  async screenshot(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;
+    }
+    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 = {
+        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;
+    }
+  }
+  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", {});
+  }
+  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;
+  }
+  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);
+      }
+      return keep;
+    });
+    for (const node of filtered) {
+      if (Array.isArray(node.childIds)) {
+        node.childIds = node.childIds.filter((id) => keepIds.has(id));
+      }
+    }
+    return this.replaceAxNodes(snapshot, filtered);
+  }
+  replaceAxNodes(snapshot, nodes) {
+    if (Array.isArray(snapshot)) {
+      return nodes;
+    }
+    if (snapshot && typeof snapshot === "object") {
+      snapshot.nodes = nodes;
+    }
+    return snapshot;
+  }
+  isInteractiveAxNode(node) {
+    const role = this.getAxRole(node);
+    return Boolean(role && INTERACTIVE_AX_ROLES.has(role));
+  }
+  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);
+      }
+    }
+    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)
+      );
+    }
+    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;
+  }
+  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;
+      }
+      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;
+  }
+  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.`
+        );
+        break;
+      }
+      try {
+        const described = await this.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 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.`);
+        }
+      }
+    }
+    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."] };
+    }
+    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] };
+      }
+      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 error = new InspectError(
+        "EVALUATION_FAILED",
+        "Failed to evaluate HTML snapshot.",
+        { retryable: false }
+      );
+      this.recordError(error);
+      throw error;
+    }
+    return String(
+      result?.result?.value ?? ""
+    );
+  }
+  async debuggerCommand(tabId, method, params, timeoutMs) {
+    const debuggerBridge = this.ensureDebugger();
+    const result = await debuggerBridge.command(
+      tabId,
+      method,
+      params,
+      timeoutMs
+    );
+    if (!result.ok) {
+      const error = this.mapDebuggerError(result.error);
+      this.recordError(error);
+      throw error;
+    }
+    return result.result;
+  }
+  mapDebuggerError(error) {
+    const allowed = [
+      "INSPECT_UNAVAILABLE",
+      "EXTENSION_DISCONNECTED",
+      "DEBUGGER_IN_USE",
+      "ATTACH_DENIED",
+      "TAB_NOT_FOUND",
+      "NOT_SUPPORTED",
+      "TIMEOUT",
+      "EVALUATION_FAILED",
+      "ARTIFACT_IO_ERROR",
+      "INVALID_ARGUMENT",
+      "INTERNAL"
+    ];
+    const code = allowed.includes(error.code) ? error.code : "INSPECT_UNAVAILABLE";
+    return new InspectError(code, error.message, {
+      retryable: error.retryable,
+      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);
+      if (session.state === "INIT" /* INIT */ || session.state === "DRIVE_READY" /* DRIVE_READY */) {
+        this.registry.apply(sessionId, "INSPECT_CONNECTED");
+      } else if (session.state === "DEGRADED_INSPECT" /* DEGRADED_INSPECT */) {
+        this.registry.apply(sessionId, "RECOVER_SUCCEEDED");
+      }
+    } catch {
+    }
+  }
+  recordError(error) {
+    this.lastError = error;
+    this.lastErrorAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  buildUnavailableError() {
+    return new InspectError(
+      "INSPECT_UNAVAILABLE",
+      "Inspect is not available until the debugger bridge is configured.",
+      { retryable: false }
+    );
+  }
+  throwUnavailable() {
+    const error = this.buildUnavailableError();
+    this.recordError(error);
+    throw error;
+  }
+  requireSession(sessionId) {
+    try {
+      return this.registry.require(sessionId);
+    } catch (error) {
+      if (error instanceof SessionError) {
+        const code = error.code === "SESSION_CLOSED" ? "SESSION_CLOSED" : "SESSION_NOT_FOUND";
+        const wrapped2 = new InspectError(code, error.message);
+        this.recordError(wrapped2);
+        throw wrapped2;
+      }
+      const wrapped = new InspectError("INTERNAL", "Failed to load session.");
+      this.recordError(wrapped);
+      throw wrapped;
+    }
+  }
+};
+var createInspectService = (options) => new InspectService(options);
+
+// packages/shared/src/errors.ts
+var import_zod = require("zod");
+var ErrorCodeSchema = import_zod.z.enum([
+  "UNKNOWN",
+  "INVALID_ARGUMENT",
+  "NOT_FOUND",
+  "ALREADY_EXISTS",
+  "FAILED_PRECONDITION",
+  "UNAUTHORIZED",
+  "FORBIDDEN",
+  "CONFLICT",
+  "TIMEOUT",
+  "CANCELLED",
+  "UNAVAILABLE",
+  "RATE_LIMITED",
+  "NOT_IMPLEMENTED",
+  "INTERNAL",
+  "SESSION_NOT_FOUND",
+  "SESSION_CLOSED",
+  "SESSION_BROKEN",
+  "DRIVE_UNAVAILABLE",
+  "INSPECT_UNAVAILABLE",
+  "EXTENSION_DISCONNECTED",
+  "DEBUGGER_IN_USE",
+  "ATTACH_DENIED",
+  "TAB_NOT_FOUND",
+  "NOT_SUPPORTED",
+  "LOCATOR_NOT_FOUND",
+  "NAVIGATION_FAILED",
+  "EVALUATION_FAILED",
+  "ARTIFACT_IO_ERROR"
+]);
+var ErrorInfoSchema = import_zod.z.object({
+  code: ErrorCodeSchema,
+  message: import_zod.z.string(),
+  retryable: import_zod.z.boolean(),
+  details: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+var ErrorEnvelopeSchema = import_zod.z.object({
+  ok: import_zod.z.literal(false),
+  error: ErrorInfoSchema
+});
+var successEnvelopeSchema = (result) => import_zod.z.object({
+  ok: import_zod.z.literal(true),
+  result
+});
+var apiEnvelopeSchema = (result) => import_zod.z.union([successEnvelopeSchema(result), ErrorEnvelopeSchema]);
+
+// packages/shared/src/schemas.ts
+var import_zod2 = require("zod");
+var LocatorRoleSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  value: import_zod2.z.string().optional()
+});
+var LocatorSchema = import_zod2.z.object({
+  ref: import_zod2.z.string().min(1).optional(),
+  testid: import_zod2.z.string().min(1).optional(),
+  css: import_zod2.z.string().min(1).optional(),
+  text: import_zod2.z.string().min(1).optional(),
+  role: LocatorRoleSchema.optional()
+}).refine(
+  (value) => Boolean(
+    value.ref || value.testid || value.css || value.text || value.role
+  ),
+  {
+    message: "Locator must include at least one selector."
+  }
+);
+var OpResultSchema = import_zod2.z.object({
+  ok: import_zod2.z.literal(true),
+  message: import_zod2.z.string().optional(),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var SessionStateSchema = import_zod2.z.enum([
+  "INIT",
+  "DRIVE_READY",
+  "INSPECT_READY",
+  "READY",
+  "DEGRADED_DRIVE",
+  "DEGRADED_INSPECT",
+  "BROKEN",
+  "CLOSED"
+]);
+var SessionInfoSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string(),
+  state: SessionStateSchema,
+  created_at: import_zod2.z.string().datetime().optional()
+});
+var SessionPlaneStatusSchema = import_zod2.z.object({
+  connected: import_zod2.z.boolean(),
+  last_seen_at: import_zod2.z.string().datetime().optional(),
+  error: ErrorInfoSchema.optional()
+});
+var SessionStatusSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string(),
+  state: SessionStateSchema,
+  drive: SessionPlaneStatusSchema.optional(),
+  inspect: SessionPlaneStatusSchema.optional(),
+  updated_at: import_zod2.z.string().datetime().optional()
+});
+var RecoverResultSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string(),
+  recovered: import_zod2.z.boolean(),
+  state: SessionStateSchema,
+  message: import_zod2.z.string().optional()
+});
+var DiagnosticCheckSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  ok: import_zod2.z.boolean(),
+  message: import_zod2.z.string().optional(),
+  details: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
+});
+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(),
+  extension: import_zod2.z.object({
+    connected: import_zod2.z.boolean().optional(),
+    version: import_zod2.z.string().optional(),
+    last_seen_at: import_zod2.z.string().datetime().optional()
+  }).optional(),
+  debugger: import_zod2.z.object({
+    attached: import_zod2.z.boolean().optional(),
+    idle_timeout_ms: import_zod2.z.number().finite().optional(),
+    console_buffer_size: import_zod2.z.number().finite().optional(),
+    network_buffer_size: import_zod2.z.number().finite().optional(),
+    last_error: ErrorInfoSchema.optional()
+  }).optional(),
+  artifacts: import_zod2.z.object({
+    root_dir: import_zod2.z.string().optional()
+  }).optional(),
+  recovery: import_zod2.z.object({
+    last_attempt: import_zod2.z.object({
+      session_id: import_zod2.z.string(),
+      recovered: import_zod2.z.boolean(),
+      state: SessionStateSchema,
+      message: import_zod2.z.string().optional(),
+      at: import_zod2.z.string()
+    }).optional(),
+    attempts: import_zod2.z.array(
+      import_zod2.z.object({
+        session_id: import_zod2.z.string(),
+        recovered: import_zod2.z.boolean(),
+        state: SessionStateSchema,
+        message: import_zod2.z.string().optional(),
+        at: import_zod2.z.string()
+      })
+    ).optional(),
+    success_count: import_zod2.z.number().finite().optional(),
+    failure_count: import_zod2.z.number().finite().optional(),
+    success_rate: import_zod2.z.number().finite().optional(),
+    recent_failure_count: import_zod2.z.number().finite().optional(),
+    loop_detected: import_zod2.z.boolean().optional()
+  }).optional(),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional(),
+  notes: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var SessionIdSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1)
+});
+var SessionCreateInputSchema = import_zod2.z.object({}).strict().default({});
+var SessionCreateOutputSchema = SessionInfoSchema;
+var SessionStatusInputSchema = SessionIdSchema;
+var SessionStatusOutputSchema = SessionStatusSchema;
+var SessionRecoverInputSchema = SessionIdSchema;
+var SessionRecoverOutputSchema = RecoverResultSchema;
+var SessionCloseInputSchema = SessionIdSchema;
+var SessionCloseOutputSchema = import_zod2.z.object({
+  ok: import_zod2.z.boolean()
+});
+var DriveWaitConditionSchema = import_zod2.z.object({
+  kind: import_zod2.z.enum(["locator_visible", "text_present", "url_matches"]),
+  value: import_zod2.z.string().min(1)
+});
+var DriveNavigateInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  url: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite().optional(),
+  wait: import_zod2.z.enum(["none", "domcontentloaded"]).default("domcontentloaded")
+});
+var DriveNavigateOutputSchema = OpResultSchema;
+var DriveGoBackInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveGoBackOutputSchema = OpResultSchema;
+var DriveGoForwardInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveGoForwardOutputSchema = OpResultSchema;
+var DriveBackInputSchema = DriveGoBackInputSchema;
+var DriveBackOutputSchema = OpResultSchema;
+var DriveForwardInputSchema = DriveGoForwardInputSchema;
+var DriveForwardOutputSchema = OpResultSchema;
+var DriveClickInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  locator: LocatorSchema,
+  tab_id: import_zod2.z.number().finite().optional(),
+  click_count: import_zod2.z.number().finite().optional()
+});
+var DriveClickOutputSchema = OpResultSchema;
+var DriveHoverInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  locator: LocatorSchema,
+  delay_ms: import_zod2.z.number().min(0).max(1e4).optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveHoverOutputSchema = import_zod2.z.object({
+  format: import_zod2.z.literal("html"),
+  snapshot: import_zod2.z.string()
+});
+var DriveSelectInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  locator: LocatorSchema,
+  value: import_zod2.z.string().min(1).optional(),
+  text: import_zod2.z.string().min(1).optional(),
+  index: import_zod2.z.number().int().min(0).optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+}).refine((value) => value.value || value.text || value.index !== void 0, {
+  message: "Either value, text, or index must be provided.",
+  path: ["select"]
+});
+var DriveSelectOutputSchema = OpResultSchema;
+var DriveTypeInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  locator: LocatorSchema.optional(),
+  text: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite().optional(),
+  clear: import_zod2.z.boolean().default(false),
+  submit: import_zod2.z.boolean().default(false)
+});
+var DriveTypeOutputSchema = OpResultSchema;
+var DriveFillFormFieldSchema = import_zod2.z.object({
+  selector: import_zod2.z.string().min(1).optional(),
+  locator: LocatorSchema.optional(),
+  value: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.boolean()]),
+  type: import_zod2.z.enum(["auto", "text", "select", "checkbox", "radio", "contentEditable"]).default("auto"),
+  submit: import_zod2.z.boolean().default(false)
+}).refine((value) => Boolean(value.selector || value.locator), {
+  message: "fill_form field requires selector or locator.",
+  path: ["selector"]
+});
+var DriveFillFormInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  fields: import_zod2.z.array(DriveFillFormFieldSchema).min(1),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveFillFormOutputSchema = import_zod2.z.object({
+  filled: import_zod2.z.number().finite(),
+  attempted: import_zod2.z.number().finite(),
+  errors: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var DriveDragInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  from: LocatorSchema,
+  to: LocatorSchema,
+  steps: import_zod2.z.number().min(1).max(50).default(12),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveDragOutputSchema = OpResultSchema;
+var DriveHandleDialogInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  action: import_zod2.z.enum(["accept", "dismiss"]),
+  promptText: import_zod2.z.string().optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveHandleDialogOutputSchema = OpResultSchema;
+var DialogAcceptInputSchema = SessionIdSchema.extend({
+  promptText: import_zod2.z.string().optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DialogAcceptOutputSchema = OpResultSchema;
+var DialogDismissInputSchema = SessionIdSchema.extend({
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DialogDismissOutputSchema = OpResultSchema;
+var DriveKeyModifiersSchema = import_zod2.z.object({
+  ctrl: import_zod2.z.boolean().optional(),
+  alt: import_zod2.z.boolean().optional(),
+  shift: import_zod2.z.boolean().optional(),
+  meta: import_zod2.z.boolean().optional()
+});
+var DriveKeyPressInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  key: import_zod2.z.string().min(1),
+  modifiers: DriveKeyModifiersSchema.optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveKeyPressOutputSchema = OpResultSchema;
+var DriveKeyModifierSchema = import_zod2.z.enum(["ctrl", "alt", "shift", "meta"]);
+var DriveKeyInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  key: import_zod2.z.string().min(1),
+  modifiers: import_zod2.z.array(DriveKeyModifierSchema).optional(),
+  repeat: import_zod2.z.number().int().min(1).max(50).optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveKeyOutputSchema = OpResultSchema;
+var DriveScrollInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  delta_x: import_zod2.z.number().finite().optional(),
+  delta_y: import_zod2.z.number().finite().optional(),
+  top: import_zod2.z.number().finite().optional(),
+  left: import_zod2.z.number().finite().optional(),
+  behavior: import_zod2.z.enum(["auto", "smooth"]).optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+}).refine(
+  (value) => value.delta_x !== void 0 || value.delta_y !== void 0 || value.top !== void 0 || value.left !== void 0,
+  {
+    message: "scroll requires delta_x/delta_y or top/left.",
+    path: ["scroll"]
+  }
+);
+var DriveScrollOutputSchema = OpResultSchema;
+var DriveWaitForInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  condition: DriveWaitConditionSchema,
+  timeout_ms: import_zod2.z.number().finite().optional(),
+  tab_id: import_zod2.z.number().finite().optional()
+});
+var DriveWaitForOutputSchema = OpResultSchema;
+var DriveTabInfoSchema = import_zod2.z.object({
+  tab_id: import_zod2.z.number().finite(),
+  window_id: import_zod2.z.number().finite(),
+  url: import_zod2.z.string().min(1),
+  title: import_zod2.z.string(),
+  active: import_zod2.z.boolean().optional(),
+  last_active_at: import_zod2.z.string().datetime().optional()
+});
+var DriveTabListInputSchema = SessionIdSchema;
+var DriveTabListOutputSchema = import_zod2.z.object({
+  tabs: import_zod2.z.array(DriveTabInfoSchema)
+});
+var DriveTabActivateInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite()
+});
+var DriveTabActivateOutputSchema = OpResultSchema;
+var DriveTabCloseInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  tab_id: import_zod2.z.number().finite()
+});
+var DriveTabCloseOutputSchema = OpResultSchema;
+var InspectDomFormatSchema = import_zod2.z.enum(["ax", "html"]);
+var InspectConsistencySchema = import_zod2.z.enum(["best_effort", "quiesce"]);
+var TargetHintSchema = import_zod2.z.object({
+  url: import_zod2.z.string().min(1).optional(),
+  title: import_zod2.z.string().min(1).optional(),
+  last_active_at: import_zod2.z.string().optional(),
+  lastActiveAt: import_zod2.z.string().optional()
+});
+var FormFieldInfoSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  type: import_zod2.z.string(),
+  value: import_zod2.z.string(),
+  options: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var FormInfoSchema = import_zod2.z.object({
+  selector: import_zod2.z.string(),
+  action: import_zod2.z.string().optional(),
+  method: import_zod2.z.string().optional(),
+  fields: import_zod2.z.array(FormFieldInfoSchema)
+});
+var StorageEntrySchema = import_zod2.z.object({
+  key: import_zod2.z.string(),
+  value: import_zod2.z.string()
+});
+var PageStateSchema = import_zod2.z.object({
+  forms: import_zod2.z.array(FormInfoSchema),
+  localStorage: import_zod2.z.array(StorageEntrySchema),
+  sessionStorage: import_zod2.z.array(StorageEntrySchema),
+  cookies: import_zod2.z.array(StorageEntrySchema),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var DomSnapshotSchema = import_zod2.z.object({
+  format: InspectDomFormatSchema,
+  snapshot: import_zod2.z.unknown()
+}).passthrough();
+var InspectDomSnapshotInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  format: InspectDomFormatSchema.default("ax"),
+  consistency: InspectConsistencySchema.default("best_effort"),
+  interactive: import_zod2.z.boolean().default(false),
+  compact: import_zod2.z.boolean().default(false),
+  selector: import_zod2.z.string().min(1).optional(),
+  target: TargetHintSchema.optional()
+});
+var InspectDomSnapshotOutputSchema = DomSnapshotSchema;
+var DomDiffResultSchema = import_zod2.z.object({
+  added: import_zod2.z.array(import_zod2.z.string()),
+  removed: import_zod2.z.array(import_zod2.z.string()),
+  changed: import_zod2.z.array(import_zod2.z.string()),
+  summary: import_zod2.z.string()
+});
+var InspectDomDiffInputSchema = SessionIdSchema;
+var InspectDomDiffOutputSchema = DomDiffResultSchema;
+var InspectFindRoleInputSchema = SessionIdSchema.extend({
+  kind: import_zod2.z.literal("role"),
+  role: import_zod2.z.string().min(1),
+  name: import_zod2.z.string().min(1).optional(),
+  target: TargetHintSchema.optional()
+});
+var InspectFindTextInputSchema = SessionIdSchema.extend({
+  kind: import_zod2.z.literal("text"),
+  text: import_zod2.z.string().min(1),
+  target: TargetHintSchema.optional()
+});
+var InspectFindLabelInputSchema = SessionIdSchema.extend({
+  kind: import_zod2.z.literal("label"),
+  label: import_zod2.z.string().min(1),
+  target: TargetHintSchema.optional()
+});
+var InspectFindInputSchema = import_zod2.z.discriminatedUnion("kind", [
+  InspectFindRoleInputSchema,
+  InspectFindTextInputSchema,
+  InspectFindLabelInputSchema
+]);
+var InspectFindMatchSchema = import_zod2.z.object({
+  ref: import_zod2.z.string(),
+  role: import_zod2.z.string().optional(),
+  name: import_zod2.z.string().optional()
+});
+var InspectFindOutputSchema = import_zod2.z.object({
+  matches: import_zod2.z.array(InspectFindMatchSchema),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var InspectPageStateInputSchema = SessionIdSchema.extend({
+  target: TargetHintSchema.optional()
+});
+var InspectPageStateOutputSchema = PageStateSchema;
+var InspectExtractContentFormatSchema = import_zod2.z.enum([
+  "markdown",
+  "text",
+  "article_json"
+]);
+var InspectExtractContentInputSchema = SessionIdSchema.extend({
+  format: InspectExtractContentFormatSchema.default("markdown"),
+  include_metadata: import_zod2.z.boolean().default(true),
+  target: TargetHintSchema.optional()
+});
+var InspectExtractContentOutputSchema = import_zod2.z.object({
+  content: import_zod2.z.string(),
+  title: import_zod2.z.string().optional(),
+  byline: import_zod2.z.string().optional(),
+  excerpt: import_zod2.z.string().optional(),
+  siteName: import_zod2.z.string().optional(),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var InspectConsoleListInputSchema = SessionIdSchema.extend({
+  target: TargetHintSchema.optional()
+});
+var ConsoleSourceLocationSchema = import_zod2.z.object({
+  url: import_zod2.z.string().optional(),
+  // 1-based line/column for human readability.
+  line: import_zod2.z.number().int().positive().optional(),
+  column: import_zod2.z.number().int().positive().optional()
+}).passthrough();
+var ConsoleStackFrameSchema = import_zod2.z.object({
+  functionName: import_zod2.z.string().optional(),
+  url: import_zod2.z.string().optional(),
+  // 1-based line/column for human readability.
+  line: import_zod2.z.number().int().positive().optional(),
+  column: import_zod2.z.number().int().positive().optional()
+}).passthrough();
+var ConsoleRemoteObjectSchema = import_zod2.z.object({
+  type: import_zod2.z.string().optional(),
+  subtype: import_zod2.z.string().optional(),
+  description: import_zod2.z.string().optional(),
+  value: import_zod2.z.unknown().optional(),
+  unserializableValue: import_zod2.z.string().optional()
+}).passthrough();
+var ConsoleEntrySchema = import_zod2.z.object({
+  level: import_zod2.z.string().optional(),
+  text: import_zod2.z.string().optional(),
+  timestamp: import_zod2.z.string().datetime().optional(),
+  source: ConsoleSourceLocationSchema.optional(),
+  stack: import_zod2.z.array(ConsoleStackFrameSchema).optional(),
+  exception: ConsoleRemoteObjectSchema.optional(),
+  args: import_zod2.z.array(ConsoleRemoteObjectSchema).optional()
+}).passthrough();
+var ConsoleListSchema = import_zod2.z.object({
+  entries: import_zod2.z.array(ConsoleEntrySchema)
+}).passthrough();
+var InspectConsoleListOutputSchema = ConsoleListSchema;
+var ArtifactInfoSchema = import_zod2.z.object({
+  artifact_id: import_zod2.z.string(),
+  path: import_zod2.z.string(),
+  mime: import_zod2.z.string()
+});
+var InspectNetworkHarInputSchema = SessionIdSchema.extend({
+  target: TargetHintSchema.optional()
+});
+var InspectNetworkHarOutputSchema = ArtifactInfoSchema;
+var InspectEvaluateInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1),
+  expression: import_zod2.z.string().min(1).optional(),
+  target: TargetHintSchema.optional()
+});
+var EvaluateResultSchema = import_zod2.z.object({
+  value: import_zod2.z.unknown().optional(),
+  exception: import_zod2.z.unknown().optional()
+}).passthrough();
+var InspectEvaluateOutputSchema = EvaluateResultSchema;
+var InspectPerformanceMetricsInputSchema = SessionIdSchema.extend({
+  target: TargetHintSchema.optional()
+});
+var PerformanceMetricSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  value: import_zod2.z.number().finite()
+}).passthrough();
+var PerformanceMetricsSchema = import_zod2.z.object({
+  metrics: import_zod2.z.array(PerformanceMetricSchema)
+}).passthrough();
+var InspectPerformanceMetricsOutputSchema = PerformanceMetricsSchema;
+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),
+  format: import_zod2.z.enum(["png", "jpeg", "webp"]).default("png"),
+  quality: import_zod2.z.number().min(0).max(100).optional()
+});
+var ArtifactsScreenshotOutputSchema = ArtifactInfoSchema;
+var DiagnosticsDoctorInputSchema = import_zod2.z.object({
+  session_id: import_zod2.z.string().min(1).optional()
+});
+var DiagnosticsDoctorOutputSchema = DiagnosticReportSchema;
+
+// packages/core/src/routes/artifacts.ts
+var sendArtifactsError = (res, code, message, details, retryable = false) => {
+  sendError(res, errorStatus(code), {
+    code,
+    message,
+    retryable,
+    ...details ? { details } : {}
+  });
+};
+var registerArtifactsRoutes = (router, options = {}) => {
+  const inspect = options.inspectService ?? (options.registry ? createInspectService({ registry: options.registry }) : void 0);
+  router.post("/artifacts/screenshot", async (req, res) => {
+    if (!isRecord(req.body)) {
+      sendArtifactsError(
+        res,
+        "INVALID_ARGUMENT",
+        "Request body must be an object."
+      );
+      return;
+    }
+    const parsed = ArtifactsScreenshotInputSchema.safeParse(req.body);
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      sendArtifactsError(
+        res,
+        "INVALID_ARGUMENT",
+        issue?.message ?? "Invalid screenshot request.",
+        issue?.path.length ? {
+          field: issue.path.map((part) => String(part)).join(".")
+        } : void 0
+      );
+      return;
+    }
+    const input = parsed.data;
+    const target = input.fullPage ? "full" : input.target;
+    try {
+      if (!inspect) {
+        sendArtifactsError(
+          res,
+          "NOT_IMPLEMENTED",
+          "artifacts.screenshot is not implemented yet."
+        );
+        return;
+      }
+      const hint = deriveHintFromTabs(
+        options.extensionBridge?.getStatus().tabs ?? []
+      );
+      const result = await inspect.screenshot({
+        sessionId: input.session_id,
+        target,
+        format: input.format,
+        quality: input.quality,
+        targetHint: hint
+      });
+      sendResult(res, result);
+    } catch (error) {
+      if (error instanceof InspectError) {
+        sendArtifactsError(
+          res,
+          error.code,
+          error.message,
+          error.details,
+          error.retryable
+        );
+        return;
+      }
+      sendArtifactsError(
+        res,
+        "ARTIFACT_IO_ERROR",
+        "Failed to capture screenshot."
+      );
+    }
+  });
+};
+
+// packages/core/src/diagnostics.ts
+var buildDiagnosticReport = (sessionId, context = {}) => {
+  const extensionConnected = context.extension?.connected ?? false;
+  const debuggerAttached = context.debugger?.attached ?? false;
+  const sessionState = context.sessionState;
+  const checks = [
+    {
+      name: "extension.connected",
+      ok: extensionConnected,
+      message: extensionConnected ? "Extension is connected." : "Extension is not connected."
+    },
+    {
+      name: "debugger.attached",
+      ok: debuggerAttached,
+      message: debuggerAttached ? "Debugger is attached." : "Debugger is not attached."
+    },
+    {
+      name: "session.state",
+      ok: Boolean(sessionState),
+      message: sessionState ? `Session state is ${sessionState}.` : sessionId ? "Session state unavailable." : "Session id not provided.",
+      details: {
+        session_id: sessionId || null,
+        state: sessionState ?? "UNKNOWN"
+      }
+    }
+  ];
+  if (context.driveLastError) {
+    checks.push({
+      name: "drive.last_error",
+      ok: false,
+      message: context.driveLastError.message,
+      details: {
+        code: context.driveLastError.code,
+        retryable: context.driveLastError.retryable,
+        at: context.driveLastError.at
+      }
+    });
+  }
+  if (context.inspectLastError) {
+    checks.push({
+      name: "inspect.last_error",
+      ok: false,
+      message: context.inspectLastError.message,
+      details: {
+        code: context.inspectLastError.code,
+        retryable: context.inspectLastError.retryable,
+        at: context.inspectLastError.at
+      }
+    });
+  }
+  if (context.recoveryAttempt) {
+    checks.push({
+      name: "recovery.last_attempt",
+      ok: context.recoveryAttempt.recovered,
+      message: context.recoveryAttempt.message ?? "Recovery attempt recorded.",
+      details: {
+        session_id: context.recoveryAttempt.sessionId,
+        state: context.recoveryAttempt.state,
+        at: context.recoveryAttempt.at
+      }
+    });
+  }
+  const formatRecoveryAttempt = (attempt) => ({
+    session_id: attempt.sessionId,
+    recovered: attempt.recovered,
+    state: attempt.state,
+    message: attempt.message,
+    at: attempt.at
+  });
+  const recoveryAttempts = context.recoveryMetrics?.attempts;
+  const lastRecoveryAttempt = context.recoveryAttempt ?? (recoveryAttempts && recoveryAttempts[recoveryAttempts.length - 1]);
+  const report = {
+    ok: checks.every((check) => check.ok),
+    session_id: sessionId,
+    checks,
+    extension: {
+      connected: extensionConnected,
+      last_seen_at: context.extension?.lastSeenAt
+    },
+    debugger: context.debugger ? {
+      attached: debuggerAttached,
+      idle_timeout_ms: context.debugger.idle_timeout_ms,
+      console_buffer_size: context.debugger.console_buffer_size,
+      network_buffer_size: context.debugger.network_buffer_size,
+      last_error: context.debugger.last_error
+    } : void 0,
+    artifacts: sessionId ? {
+      root_dir: getArtifactRootDir(sessionId)
+    } : void 0,
+    recovery: context.recoveryMetrics || lastRecoveryAttempt ? {
+      ...lastRecoveryAttempt ? { last_attempt: formatRecoveryAttempt(lastRecoveryAttempt) } : {},
+      ...recoveryAttempts ? { attempts: recoveryAttempts.map(formatRecoveryAttempt) } : {},
+      ...context.recoveryMetrics ? {
+        success_count: context.recoveryMetrics.successCount,
+        failure_count: context.recoveryMetrics.failureCount,
+        success_rate: context.recoveryMetrics.successRate,
+        recent_failure_count: context.recoveryMetrics.recentFailureCount,
+        loop_detected: context.recoveryMetrics.loopDetected
+      } : {}
+    } : void 0,
+    notes: ["Diagnostics include runtime status; some checks may be stubbed."]
+  };
+  return report;
+};
+
+// packages/core/src/routes/diagnostics.ts
+var registerDiagnosticsRoutes = (router, options = {}) => {
+  router.post("/diagnostics/doctor", (req, res) => {
+    let sessionId;
+    if (req.body !== void 0) {
+      if (!isRecord(req.body)) {
+        sendError(res, 400, {
+          code: "INVALID_ARGUMENT",
+          message: "Request body must be an object.",
+          retryable: false
+        });
+        return;
+      }
+      const raw = req.body.session_id;
+      if (raw !== void 0 && (typeof raw !== "string" || raw.length === 0)) {
+        sendError(res, 400, {
+          code: "INVALID_ARGUMENT",
+          message: "session_id must be a non-empty string.",
+          retryable: false,
+          details: { field: "session_id" }
+        });
+        return;
+      }
+      sessionId = raw;
+    }
+    try {
+      const context = {};
+      if (options.registry && sessionId) {
+        try {
+          const session = options.registry.require(sessionId);
+          context.sessionState = session.state;
+        } catch {
+        }
+      }
+      if (options.extensionBridge) {
+        const status = options.extensionBridge.getStatus();
+        context.extension = {
+          connected: status.connected,
+          lastSeenAt: status.lastSeenAt
+        };
+      }
+      if (options.debuggerBridge) {
+        const settings = options.debuggerBridge.getSettings();
+        const lastError = options.debuggerBridge.getLastError();
+        context.debugger = {
+          attached: options.debuggerBridge.hasAttachments(),
+          idle_timeout_ms: settings.idleTimeoutMs,
+          console_buffer_size: settings.consoleBufferSize,
+          network_buffer_size: settings.networkBufferSize,
+          last_error: lastError ? {
+            code: lastError.error.code,
+            message: lastError.error.message,
+            retryable: lastError.error.retryable,
+            details: lastError.error.details
+          } : void 0
+        };
+      }
+      if (options.drive) {
+        const lastError = options.drive.getLastError();
+        if (lastError) {
+          context.driveLastError = {
+            code: lastError.error.code,
+            message: lastError.error.message,
+            retryable: lastError.error.retryable,
+            at: lastError.at
+          };
+        }
+      }
+      if (options.inspectService) {
+        const lastError = options.inspectService.getLastError();
+        if (lastError) {
+          context.inspectLastError = {
+            code: lastError.error.code,
+            message: lastError.error.message,
+            retryable: lastError.error.retryable,
+            at: lastError.at
+          };
+        }
+      }
+      if (options.recoveryTracker) {
+        const attempt = options.recoveryTracker.getLastAttempt();
+        if (attempt) {
+          context.recoveryAttempt = {
+            sessionId: attempt.sessionId,
+            recovered: attempt.recovered,
+            state: attempt.state,
+            message: attempt.message,
+            at: attempt.at
+          };
+        }
+        context.recoveryMetrics = options.recoveryTracker.getMetrics();
+      }
+      const report = buildDiagnosticReport(sessionId, context);
+      sendResult(res, report);
+    } catch {
+      sendError(res, 500, {
+        code: "INTERNAL",
+        message: "Failed to build diagnostics report.",
+        retryable: false
+      });
+    }
+  });
+};
+
+// packages/core/src/routes/drive.ts
+var parseBody = (schema, body) => {
+  const result = schema.safeParse(body);
+  if (result.success) {
+    return { data: result.data };
+  }
+  const issue = result.error.issues[0];
+  const details = issue && issue.path.length > 0 ? { field: issue.path.map((part) => part.toString()).join(".") } : void 0;
+  return {
+    error: {
+      message: issue?.message ?? "Request body is invalid.",
+      ...details ? { details } : {}
+    }
+  };
+};
+var makeHandler = (action, schema, drive, options = {}) => {
+  return (req, res) => {
+    const parsed = parseBody(schema, req.body ?? {});
+    if (parsed.error) {
+      sendError(res, errorStatus("INVALID_ARGUMENT"), {
+        code: "INVALID_ARGUMENT",
+        message: parsed.error.message,
+        retryable: false,
+        ...parsed.error.details ? { details: parsed.error.details } : {}
+      });
+      return;
+    }
+    const body = parsed.data;
+    const sessionId = body.session_id;
+    const params = { ...body };
+    delete params.session_id;
+    const timeoutMs = options.timeoutFromParams ? options.timeoutFromParams(params) : void 0;
+    void drive.execute(sessionId, action, params, timeoutMs).then((result) => {
+      if (result.ok) {
+        const payload = result.result === void 0 ? options.defaultResult ?? { ok: true } : result.result;
+        sendResult(res, payload);
+        return;
+      }
+      sendError(res, errorStatus(result.error.code), result.error);
+    }).catch((error) => {
+      console.error("Drive execute failed:", error);
+      sendError(res, errorStatus("INTERNAL"), {
+        code: "INTERNAL",
+        message: "Unexpected error while executing drive action.",
+        retryable: false,
+        details: {
+          hint: error instanceof Error ? error.message : "Unknown error."
+        }
+      });
+    });
+  };
+};
+var makeDialogHandler = (action, schema, drive) => {
+  return (req, res) => {
+    const parsed = parseBody(schema, req.body ?? {});
+    if (parsed.error) {
+      sendError(res, errorStatus("INVALID_ARGUMENT"), {
+        code: "INVALID_ARGUMENT",
+        message: parsed.error.message,
+        retryable: false,
+        ...parsed.error.details ? { details: parsed.error.details } : {}
+      });
+      return;
+    }
+    const body = parsed.data;
+    const { session_id: sessionId, ...rest } = body;
+    const params = { ...rest, action };
+    void drive.execute(sessionId, "drive.handle_dialog", params).then((result) => {
+      if (result.ok) {
+        const payload = result.result === void 0 ? { ok: true } : result.result;
+        sendResult(res, payload);
+        return;
+      }
+      sendError(res, errorStatus(result.error.code), result.error);
+    }).catch((error) => {
+      console.error("Drive execute failed:", error);
+      sendError(res, errorStatus("INTERNAL"), {
+        code: "INTERNAL",
+        message: "Unexpected error while executing drive action.",
+        retryable: false,
+        details: {
+          hint: error instanceof Error ? error.message : "Unknown error."
+        }
+      });
+    });
+  };
+};
+var registerDriveRoutes = (router, options) => {
+  const { drive } = options;
+  router.post(
+    "/drive/navigate",
+    makeHandler("drive.navigate", DriveNavigateInputSchema, drive)
+  );
+  router.post(
+    "/drive/go_back",
+    makeHandler("drive.go_back", DriveGoBackInputSchema, drive)
+  );
+  router.post(
+    "/drive/go_forward",
+    makeHandler("drive.go_forward", DriveGoForwardInputSchema, drive)
+  );
+  router.post(
+    "/drive/back",
+    makeHandler("drive.back", DriveBackInputSchema, drive)
+  );
+  router.post(
+    "/drive/forward",
+    makeHandler("drive.forward", DriveForwardInputSchema, drive)
+  );
+  router.post(
+    "/drive/click",
+    makeHandler("drive.click", DriveClickInputSchema, drive)
+  );
+  router.post(
+    "/drive/hover",
+    makeHandler("drive.hover", DriveHoverInputSchema, drive)
+  );
+  router.post(
+    "/drive/select",
+    makeHandler("drive.select", DriveSelectInputSchema, drive)
+  );
+  router.post(
+    "/drive/type",
+    makeHandler("drive.type", DriveTypeInputSchema, drive)
+  );
+  router.post(
+    "/drive/fill_form",
+    makeHandler("drive.fill_form", DriveFillFormInputSchema, drive)
+  );
+  router.post(
+    "/drive/drag",
+    makeHandler("drive.drag", DriveDragInputSchema, drive)
+  );
+  router.post(
+    "/drive/handle_dialog",
+    makeHandler("drive.handle_dialog", DriveHandleDialogInputSchema, drive)
+  );
+  router.post(
+    "/dialog/accept",
+    makeDialogHandler("accept", DialogAcceptInputSchema, drive)
+  );
+  router.post(
+    "/dialog/dismiss",
+    makeDialogHandler("dismiss", DialogDismissInputSchema, drive)
+  );
+  router.post(
+    "/drive/key",
+    makeHandler("drive.key", DriveKeyInputSchema, drive)
+  );
+  router.post(
+    "/drive/key_press",
+    makeHandler("drive.key_press", DriveKeyPressInputSchema, drive)
+  );
+  router.post(
+    "/drive/scroll",
+    makeHandler("drive.scroll", DriveScrollInputSchema, drive)
+  );
+  router.post(
+    "/drive/wait_for",
+    makeHandler("drive.wait_for", DriveWaitForInputSchema, drive, {
+      timeoutFromParams: (params) => {
+        const timeout = params.timeout_ms;
+        if (typeof timeout === "number" && Number.isFinite(timeout)) {
+          return Math.max(0, timeout + 1e3);
+        }
+        return void 0;
+      }
+    })
+  );
+  router.post(
+    "/drive/tab_list",
+    makeHandler("drive.tab_list", DriveTabListInputSchema, drive)
+  );
+  router.post(
+    "/drive/tab_activate",
+    makeHandler("drive.tab_activate", DriveTabActivateInputSchema, drive)
+  );
+  router.post(
+    "/drive/tab_close",
+    makeHandler("drive.tab_close", DriveTabCloseInputSchema, drive)
+  );
+};
+
+// packages/core/src/routes/inspect.ts
+var sendInspectError = (res, code, message, retryable, details) => {
+  sendError(res, errorStatus(code), {
+    code,
+    message,
+    retryable,
+    ...details ? { details } : {}
+  });
+};
+var parseBody2 = (schema, body) => {
+  const result = schema.safeParse(body);
+  if (result.success) {
+    return { data: result.data };
+  }
+  const issue = result.error.issues[0];
+  const details = issue && issue.path.length > 0 ? { field: issue.path.map((part) => part.toString()).join(".") } : void 0;
+  return {
+    error: {
+      message: issue?.message ?? "Request body is invalid.",
+      ...details ? { details } : {}
+    }
+  };
+};
+var readTargetHint = (target) => {
+  if (!target) {
+    return void 0;
+  }
+  const url = typeof target.url === "string" ? target.url : void 0;
+  const title = typeof target.title === "string" ? target.title : void 0;
+  const lastActiveAtRaw = target.last_active_at ?? target.lastActiveAt;
+  const lastActiveAt = typeof lastActiveAtRaw === "string" ? lastActiveAtRaw : void 0;
+  if (!url && !title && !lastActiveAt) {
+    return void 0;
+  }
+  return { url, title, lastActiveAt };
+};
+var resolveTargetHint = (target, options) => {
+  const explicit = readTargetHint(target);
+  if (explicit) {
+    return explicit;
+  }
+  const tabs = options.extensionBridge?.getStatus().tabs ?? [];
+  return deriveHintFromTabs(tabs);
+};
+var makeHandler2 = (schema, handler) => async (req, res) => {
+  const parsed = parseBody2(schema, req.body ?? {});
+  if (parsed.error) {
+    sendInspectError(
+      res,
+      "INVALID_ARGUMENT",
+      parsed.error.message,
+      false,
+      parsed.error.details
+    );
+    return;
+  }
+  try {
+    const result = await handler(parsed.data);
+    sendResult(res, result);
+  } catch (err) {
+    if (err instanceof InspectError) {
+      sendInspectError(
+        res,
+        err.code,
+        err.message,
+        err.retryable,
+        err.details
+      );
+      return;
+    }
+    sendInspectError(res, "INTERNAL", "Unexpected inspect error.", false);
+  }
+};
+var registerInspectRoutes = (router, options) => {
+  const inspect = options.inspectService ?? createInspectService({
+    registry: options.registry,
+    extensionBridge: options.extensionBridge
+  });
+  router.post(
+    "/inspect/dom_snapshot",
+    makeHandler2(InspectDomSnapshotInputSchema, async (body) => {
+      return await inspect.domSnapshot({
+        sessionId: body.session_id,
+        format: body.format,
+        consistency: body.consistency,
+        interactive: body.interactive,
+        compact: body.compact,
+        selector: body.selector,
+        targetHint: resolveTargetHint(body.target, options)
+      });
+    })
+  );
+  router.post(
+    "/inspect/dom_diff",
+    makeHandler2(InspectDomDiffInputSchema, async (body) => {
+      return inspect.domDiff({ sessionId: body.session_id });
+    })
+  );
+  router.post(
+    "/inspect/find",
+    makeHandler2(InspectFindInputSchema, async (body) => {
+      const targetHint = resolveTargetHint(body.target, options);
+      if (body.kind === "role") {
+        return await inspect.find({
+          sessionId: body.session_id,
+          kind: "role",
+          role: body.role,
+          name: body.name,
+          targetHint
+        });
+      }
+      if (body.kind === "text") {
+        return await inspect.find({
+          sessionId: body.session_id,
+          kind: "text",
+          text: body.text,
+          targetHint
+        });
+      }
+      return await inspect.find({
+        sessionId: body.session_id,
+        kind: "label",
+        label: body.label,
+        targetHint
+      });
+    })
+  );
+  router.post(
+    "/inspect/extract_content",
+    makeHandler2(InspectExtractContentInputSchema, async (body) => {
+      return await inspect.extractContent({
+        sessionId: body.session_id,
+        format: body.format,
+        includeMetadata: body.include_metadata,
+        targetHint: resolveTargetHint(body.target, options)
+      });
+    })
+  );
+  router.post(
+    "/inspect/page_state",
+    makeHandler2(InspectPageStateInputSchema, async (body) => {
+      return await inspect.pageState({
+        sessionId: body.session_id,
+        targetHint: resolveTargetHint(body.target, options)
+      });
+    })
+  );
+  router.post(
+    "/inspect/console_list",
+    makeHandler2(InspectConsoleListInputSchema, async (body) => {
+      return await inspect.consoleList({
+        sessionId: body.session_id,
+        targetHint: resolveTargetHint(body.target, options)
+      });
+    })
+  );
+  router.post(
+    "/inspect/network_har",
+    makeHandler2(InspectNetworkHarInputSchema, async (body) => {
+      return await inspect.networkHar({
+        sessionId: body.session_id,
+        targetHint: resolveTargetHint(body.target, options)
+      });
+    })
+  );
+  router.post(
+    "/inspect/evaluate",
+    makeHandler2(InspectEvaluateInputSchema, async (body) => {
+      return await inspect.evaluate({
+        sessionId: body.session_id,
+        expression: body.expression,
+        targetHint: resolveTargetHint(body.target, options)
+      });
+    })
+  );
+  router.post(
+    "/inspect/performance_metrics",
+    makeHandler2(InspectPerformanceMetricsInputSchema, async (body) => {
+      return await inspect.performanceMetrics({
+        sessionId: body.session_id,
+        targetHint: resolveTargetHint(body.target, options)
+      });
+    })
+  );
+};
+
+// packages/core/src/recovery.ts
+var RecoveryTracker = class {
+  constructor() {
+    this.attempts = [];
+    this.successCount = 0;
+    this.failureCount = 0;
+    this.maxAttempts = 10;
+    this.loopWindowMs = 6e4;
+    this.loopFailureThreshold = 3;
+  }
+  record(attempt) {
+    this.attempts.push(attempt);
+    if (attempt.recovered) {
+      this.successCount += 1;
+    } else {
+      this.failureCount += 1;
+    }
+    if (this.attempts.length > this.maxAttempts) {
+      this.attempts.shift();
+    }
+  }
+  getLastAttempt() {
+    return this.attempts[this.attempts.length - 1];
+  }
+  getAttempts() {
+    return [...this.attempts];
+  }
+  getMetrics(now = Date.now()) {
+    const recentFailureCount = this.attempts.reduce((count, attempt) => {
+      if (attempt.recovered) {
+        return count;
+      }
+      const timestamp = Date.parse(attempt.at);
+      if (!Number.isFinite(timestamp)) {
+        return count;
+      }
+      return now - timestamp <= this.loopWindowMs ? count + 1 : count;
+    }, 0);
+    const total = this.successCount + this.failureCount;
+    const successRate = total > 0 ? this.successCount / total : 0;
+    return {
+      attempts: this.getAttempts(),
+      successCount: this.successCount,
+      failureCount: this.failureCount,
+      successRate,
+      recentFailureCount,
+      loopDetected: recentFailureCount > this.loopFailureThreshold
+    };
+  }
+};
+
+// packages/core/src/debugger-bridge.ts
+var DEFAULT_CONSOLE_BUFFER_SIZE = 200;
+var DEFAULT_NETWORK_BUFFER_SIZE = 500;
+var DEFAULT_IDLE_TIMEOUT_MS = 15e3;
+var CONSOLE_METHODS = /* @__PURE__ */ new Set([
+  "Runtime.consoleAPICalled",
+  "Runtime.exceptionThrown",
+  "Log.entryAdded"
+]);
+var isConsoleEvent = (method) => {
+  if (CONSOLE_METHODS.has(method)) {
+    return true;
+  }
+  return method.startsWith("Runtime.") && method.includes("console");
+};
+var isNetworkEvent = (method) => method.startsWith("Network.");
+var RingBuffer = class {
+  constructor(capacity) {
+    this.entries = [];
+    this.capacity = Math.max(0, capacity);
+  }
+  push(entry) {
+    if (this.capacity <= 0) {
+      return;
+    }
+    if (this.entries.length >= this.capacity) {
+      this.entries.shift();
+    }
+    this.entries.push(entry);
+  }
+  toArray() {
+    return [...this.entries];
+  }
+  clear() {
+    this.entries.length = 0;
+  }
+};
+var DebuggerBridge = class {
+  constructor(options) {
+    this.tabs = /* @__PURE__ */ new Map();
+    this.bridge = options.extensionBridge;
+    this.consoleBufferSize = options.consoleBufferSize ?? DEFAULT_CONSOLE_BUFFER_SIZE;
+    this.networkBufferSize = options.networkBufferSize ?? DEFAULT_NETWORK_BUFFER_SIZE;
+    this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+    this.unsubscribe = this.bridge.onDebuggerEvent((event) => {
+      this.handleDebuggerEvent(event);
+    });
+  }
+  getLastError() {
+    if (!this.lastError || !this.lastErrorAt) {
+      return void 0;
+    }
+    return { error: this.lastError, at: this.lastErrorAt };
+  }
+  getSettings() {
+    return {
+      idleTimeoutMs: this.idleTimeoutMs,
+      consoleBufferSize: this.consoleBufferSize,
+      networkBufferSize: this.networkBufferSize
+    };
+  }
+  hasAttachments() {
+    for (const state of this.tabs.values()) {
+      if (state.attached) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getConsoleEvents(tabId) {
+    return this.ensureTab(tabId).console.toArray();
+  }
+  getNetworkEvents(tabId) {
+    return this.ensureTab(tabId).network.toArray();
+  }
+  clearBuffers(tabId) {
+    const state = this.tabs.get(tabId);
+    if (!state) {
+      return;
+    }
+    state.console.clear();
+    state.network.clear();
+  }
+  async attach(tabId) {
+    const state = this.ensureTab(tabId);
+    if (state.attached) {
+      this.touch(tabId, state);
+      return { ok: true, result: { attached: true } };
+    }
+    try {
+      const response = await this.bridge.requestDebugger(
+        "debugger.attach",
+        { tab_id: tabId },
+        this.idleTimeoutMs
+      );
+      if (response.status === "error") {
+        const error = response.error ?? {
+          code: "INSPECT_UNAVAILABLE",
+          message: "Debugger attach failed.",
+          retryable: false
+        };
+        this.recordError(error);
+        return { ok: false, error };
+      }
+      state.attached = true;
+      this.touch(tabId, state);
+      return { ok: true, result: { attached: true } };
+    } catch (error) {
+      const info = this.handleBridgeError(error);
+      return { ok: false, error: info };
+    }
+  }
+  async detach(tabId) {
+    const state = this.tabs.get(tabId);
+    if (!state || !state.attached) {
+      return { ok: true, result: { attached: false } };
+    }
+    try {
+      const response = await this.bridge.requestDebugger(
+        "debugger.detach",
+        { tab_id: tabId },
+        this.idleTimeoutMs
+      );
+      if (response.status === "error") {
+        const error = response.error ?? {
+          code: "INSPECT_UNAVAILABLE",
+          message: "Debugger detach failed.",
+          retryable: false
+        };
+        this.recordError(error);
+        return { ok: false, error };
+      }
+      this.markDetached(tabId);
+      return { ok: true, result: { attached: false } };
+    } catch (error) {
+      const info = this.handleBridgeError(error);
+      this.markDetached(tabId);
+      return { ok: false, error: info };
+    }
+  }
+  async command(tabId, method, params, timeoutMs = 1e4) {
+    const attachResult = await this.attach(tabId);
+    if (!attachResult.ok) {
+      return attachResult;
+    }
+    try {
+      const response = await this.bridge.requestDebugger(
+        "debugger.command",
+        {
+          tab_id: tabId,
+          method,
+          params
+        },
+        timeoutMs
+      );
+      if (response.status === "error") {
+        const error = response.error ?? {
+          code: "INSPECT_UNAVAILABLE",
+          message: "Debugger command failed.",
+          retryable: false
+        };
+        this.recordError(error);
+        return { ok: false, error };
+      }
+      this.touch(tabId, this.ensureTab(tabId));
+      return { ok: true, result: response.result };
+    } catch (error) {
+      const info = this.handleBridgeError(error);
+      return { ok: false, error: info };
+    }
+  }
+  shutdown() {
+    this.unsubscribe();
+    for (const [tabId, state] of this.tabs) {
+      if (state.idleTimer) {
+        clearTimeout(state.idleTimer);
+      }
+      this.tabs.delete(tabId);
+    }
+  }
+  handleDebuggerEvent(event) {
+    if (event.action !== "debugger.event") {
+      return;
+    }
+    const params = event.params;
+    if (!params || typeof params.tab_id !== "number") {
+      return;
+    }
+    const record = {
+      tab_id: params.tab_id,
+      method: params.method,
+      params: params.params,
+      timestamp: params.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const state = this.ensureTab(params.tab_id);
+    if (record.method === "Debugger.detached") {
+      this.markDetached(params.tab_id);
+      return;
+    }
+    if (isConsoleEvent(record.method)) {
+      state.console.push(record);
+    } else if (isNetworkEvent(record.method)) {
+      state.network.push(record);
+    }
+    this.touch(params.tab_id, state);
+  }
+  ensureTab(tabId) {
+    const existing = this.tabs.get(tabId);
+    if (existing) {
+      return existing;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const state = {
+      attached: false,
+      lastActivityAt: now,
+      console: new RingBuffer(this.consoleBufferSize),
+      network: new RingBuffer(this.networkBufferSize)
+    };
+    this.tabs.set(tabId, state);
+    return state;
+  }
+  touch(tabId, state) {
+    state.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.scheduleIdleDetach(tabId, state);
+  }
+  scheduleIdleDetach(tabId, state) {
+    if (state.idleTimer) {
+      clearTimeout(state.idleTimer);
+    }
+    state.idleTimer = setTimeout(() => {
+      void this.detach(tabId).catch((error) => {
+        console.error("DebuggerBridge idle detach failed:", error);
+      });
+    }, this.idleTimeoutMs);
+  }
+  markDetached(tabId) {
+    const state = this.tabs.get(tabId);
+    if (!state) {
+      return;
+    }
+    state.attached = false;
+    if (state.idleTimer) {
+      clearTimeout(state.idleTimer);
+      state.idleTimer = void 0;
+    }
+  }
+  recordError(error) {
+    this.lastError = error;
+    this.lastErrorAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  handleBridgeError(error) {
+    if (error instanceof ExtensionBridgeError) {
+      const info2 = toDriveError(error);
+      this.recordError(info2);
+      return info2;
+    }
+    const info = {
+      code: "INSPECT_UNAVAILABLE",
+      message: error instanceof Error ? error.message : "Debugger request failed.",
+      retryable: false
+    };
+    this.recordError(info);
+    return info;
+  }
+};
+
+// packages/core/src/server.ts
+var createCoreServer = (options = {}) => {
+  const app = (0, import_express2.default)();
+  const registry = options.registry ?? new SessionRegistry();
+  const extensionBridge = new ExtensionBridge({ registry });
+  const debuggerBridge = new DebuggerBridge({ extensionBridge });
+  const drive = new DriveController(extensionBridge, registry);
+  const inspect = createInspectService({
+    registry,
+    debuggerBridge,
+    extensionBridge
+  });
+  const recoveryTracker = new RecoveryTracker();
+  app.use(import_express2.default.json({ limit: "1mb" }));
+  app.get("/health", (_req, res) => {
+    res.status(200).json({ ok: true });
+  });
+  app.use(
+    "/session",
+    createSessionRouter(registry, {
+      driveConnected: () => extensionBridge.isConnected(),
+      inspectRecover: (sessionId) => inspect.reconnect(sessionId),
+      recordRecovery: (attempt) => recoveryTracker.record(attempt)
+    })
+  );
+  registerDriveRoutes(app, { drive });
+  registerInspectRoutes(app, {
+    registry,
+    extensionBridge,
+    inspectService: inspect
+  });
+  registerArtifactsRoutes(app, {
+    registry,
+    extensionBridge,
+    inspectService: inspect
+  });
+  registerDiagnosticsRoutes(app, {
+    registry,
+    extensionBridge,
+    debuggerBridge,
+    drive,
+    inspectService: inspect,
+    recoveryTracker
+  });
+  return {
+    app,
+    registry,
+    extensionBridge,
+    debuggerBridge,
+    drive,
+    inspect,
+    recoveryTracker
+  };
+};
+var resolveCorePort = (portOverride) => {
+  if (portOverride !== void 0) {
+    return portOverride;
+  }
+  const env = process.env.BROWSER_BRIDGE_CORE_PORT || process.env.BROWSER_VISION_CORE_PORT;
+  if (env) {
+    const parsed = Number(env);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return 3210;
+};
+var startCoreServer = (options = {}) => {
+  const host = options.host ?? "127.0.0.1";
+  const port = resolveCorePort(options.port);
+  const { app, registry, extensionBridge } = createCoreServer({
+    registry: options.registry
+  });
+  return new Promise((resolve, reject) => {
+    const server = (0, import_http.createServer)(app);
+    extensionBridge.attach(server);
+    server.listen(port, host, () => {
+      const address = server.address();
+      const resolvedPort = typeof address === "object" && address !== null ? address.port : port;
+      resolve({ app, registry, server, host, port: resolvedPort });
+    });
+    server.on("error", (error) => {
+      reject(error);
+    });
+  });
+};
+
+// packages/mcp-adapter/src/core-client.ts
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 3210;
+var DEFAULT_TIMEOUT_MS = 4e3;
+var resolveHost = (host) => {
+  const candidate = host?.trim() || process.env.BROWSER_BRIDGE_CORE_HOST || process.env.BROWSER_VISION_CORE_HOST;
+  if (candidate && candidate.length > 0) {
+    return candidate;
+  }
+  return DEFAULT_HOST;
+};
+var resolvePort = (port) => {
+  const candidate = port ?? (process.env.BROWSER_BRIDGE_CORE_PORT ? Number.parseInt(process.env.BROWSER_BRIDGE_CORE_PORT, 10) : process.env.BROWSER_VISION_CORE_PORT ? Number.parseInt(process.env.BROWSER_VISION_CORE_PORT, 10) : void 0);
+  if (candidate === void 0 || candidate === null) {
+    return DEFAULT_PORT;
+  }
+  const parsed = typeof candidate === "number" ? candidate : Number.parseInt(candidate, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid port: ${String(candidate)}`);
+  }
+  return parsed;
+};
+var normalizePath = (path3) => path3.startsWith("/") ? path3 : `/${path3}`;
+var createCoreClient = (options = {}) => {
+  const host = resolveHost(options.host);
+  const port = resolvePort(options.port);
+  const baseUrl = `http://${host}:${port}`;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const requestJson = async (path3, body) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetchImpl(`${baseUrl}${normalizePath(path3)}`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+      const raw = await response.text();
+      if (!raw) {
+        throw new Error(`Empty response from Core (${response.status}).`);
+      }
+      try {
+        return JSON.parse(raw);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown JSON parse error";
+        throw new Error(`Failed to parse Core response: ${message}`);
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  };
+  const post = async (path3, body) => {
+    return requestJson(path3, body);
+  };
+  return { baseUrl, post };
+};
+
+// packages/mcp-adapter/src/tools.ts
+var toToolResult = (payload) => {
+  const content = [{ type: "text", text: JSON.stringify(payload) }];
+  if (payload && typeof payload === "object") {
+    return {
+      content,
+      structuredContent: payload
+    };
+  }
+  return { content };
+};
+var toInternalErrorEnvelope = (error) => ({
+  ok: false,
+  error: {
+    code: "INTERNAL",
+    message: error instanceof Error ? error.message : "Unknown error.",
+    retryable: false
+  }
+});
+var envelope = (schema) => apiEnvelopeSchema(schema);
+var TOOL_DEFINITIONS = [
+  {
+    name: "session.create",
+    config: {
+      title: "Session Create",
+      description: "Create a new browser session.",
+      inputSchema: SessionCreateInputSchema,
+      outputSchema: envelope(SessionCreateOutputSchema),
+      corePath: "/session/create"
+    }
+  },
+  {
+    name: "session.status",
+    config: {
+      title: "Session Status",
+      description: "Fetch session status.",
+      inputSchema: SessionStatusInputSchema,
+      outputSchema: envelope(SessionStatusOutputSchema),
+      corePath: "/session/status"
+    }
+  },
+  {
+    name: "session.recover",
+    config: {
+      title: "Session Recover",
+      description: "Recover a session after errors.",
+      inputSchema: SessionRecoverInputSchema,
+      outputSchema: envelope(SessionRecoverOutputSchema),
+      corePath: "/session/recover"
+    }
+  },
+  {
+    name: "session.close",
+    config: {
+      title: "Session Close",
+      description: "Close a session.",
+      inputSchema: SessionCloseInputSchema,
+      outputSchema: envelope(SessionCloseOutputSchema),
+      corePath: "/session/close"
+    }
+  },
+  {
+    name: "drive.navigate",
+    config: {
+      title: "Drive Navigate",
+      description: "Navigate to a URL.",
+      inputSchema: DriveNavigateInputSchema,
+      outputSchema: envelope(DriveNavigateOutputSchema),
+      corePath: "/drive/navigate"
+    }
+  },
+  {
+    name: "drive.go_back",
+    config: {
+      title: "Drive Go Back",
+      description: "Go back in browser history.",
+      inputSchema: DriveGoBackInputSchema,
+      outputSchema: envelope(DriveGoBackOutputSchema),
+      corePath: "/drive/go_back"
+    }
+  },
+  {
+    name: "drive.go_forward",
+    config: {
+      title: "Drive Go Forward",
+      description: "Go forward in browser history.",
+      inputSchema: DriveGoForwardInputSchema,
+      outputSchema: envelope(DriveGoForwardOutputSchema),
+      corePath: "/drive/go_forward"
+    }
+  },
+  {
+    name: "drive.back",
+    config: {
+      title: "Drive Back",
+      description: "Go back in browser history.",
+      inputSchema: DriveBackInputSchema,
+      outputSchema: envelope(DriveBackOutputSchema),
+      corePath: "/drive/back"
+    }
+  },
+  {
+    name: "drive.forward",
+    config: {
+      title: "Drive Forward",
+      description: "Go forward in browser history.",
+      inputSchema: DriveForwardInputSchema,
+      outputSchema: envelope(DriveForwardOutputSchema),
+      corePath: "/drive/forward"
+    }
+  },
+  {
+    name: "drive.click",
+    config: {
+      title: "Drive Click",
+      description: "Click an element.",
+      inputSchema: DriveClickInputSchema,
+      outputSchema: envelope(DriveClickOutputSchema),
+      corePath: "/drive/click"
+    }
+  },
+  {
+    name: "drive.hover",
+    config: {
+      title: "Drive Hover",
+      description: "Hover over an element.",
+      inputSchema: DriveHoverInputSchema,
+      outputSchema: envelope(DriveHoverOutputSchema),
+      corePath: "/drive/hover"
+    }
+  },
+  {
+    name: "drive.select",
+    config: {
+      title: "Drive Select",
+      description: "Select an option in a dropdown.",
+      inputSchema: DriveSelectInputSchema,
+      outputSchema: envelope(DriveSelectOutputSchema),
+      corePath: "/drive/select"
+    }
+  },
+  {
+    name: "drive.type",
+    config: {
+      title: "Drive Type",
+      description: "Type into an element.",
+      inputSchema: DriveTypeInputSchema,
+      outputSchema: envelope(DriveTypeOutputSchema),
+      corePath: "/drive/type"
+    }
+  },
+  {
+    name: "drive.fill_form",
+    config: {
+      title: "Drive Fill Form",
+      description: "Fill multiple form fields.",
+      inputSchema: DriveFillFormInputSchema,
+      outputSchema: envelope(DriveFillFormOutputSchema),
+      corePath: "/drive/fill_form"
+    }
+  },
+  {
+    name: "drive.drag",
+    config: {
+      title: "Drive Drag",
+      description: "Drag an element to a target.",
+      inputSchema: DriveDragInputSchema,
+      outputSchema: envelope(DriveDragOutputSchema),
+      corePath: "/drive/drag"
+    }
+  },
+  {
+    name: "drive.handle_dialog",
+    config: {
+      title: "Drive Handle Dialog",
+      description: "Handle a JavaScript dialog.",
+      inputSchema: DriveHandleDialogInputSchema,
+      outputSchema: envelope(DriveHandleDialogOutputSchema),
+      corePath: "/drive/handle_dialog"
+    }
+  },
+  {
+    name: "dialog.accept",
+    config: {
+      title: "Dialog Accept",
+      description: "Accept a JavaScript dialog.",
+      inputSchema: DialogAcceptInputSchema,
+      outputSchema: envelope(DialogAcceptOutputSchema),
+      corePath: "/dialog/accept"
+    }
+  },
+  {
+    name: "dialog.dismiss",
+    config: {
+      title: "Dialog Dismiss",
+      description: "Dismiss a JavaScript dialog.",
+      inputSchema: DialogDismissInputSchema,
+      outputSchema: envelope(DialogDismissOutputSchema),
+      corePath: "/dialog/dismiss"
+    }
+  },
+  {
+    name: "drive.key",
+    config: {
+      title: "Drive Key",
+      description: "Press a keyboard key.",
+      inputSchema: DriveKeyInputSchema,
+      outputSchema: envelope(DriveKeyOutputSchema),
+      corePath: "/drive/key"
+    }
+  },
+  {
+    name: "drive.key_press",
+    config: {
+      title: "Drive Key Press",
+      description: "Press a key on the active element.",
+      inputSchema: DriveKeyPressInputSchema,
+      outputSchema: envelope(DriveKeyPressOutputSchema),
+      corePath: "/drive/key_press"
+    }
+  },
+  {
+    name: "drive.scroll",
+    config: {
+      title: "Drive Scroll",
+      description: "Scroll the active tab.",
+      inputSchema: DriveScrollInputSchema,
+      outputSchema: envelope(DriveScrollOutputSchema),
+      corePath: "/drive/scroll"
+    }
+  },
+  {
+    name: "drive.wait_for",
+    config: {
+      title: "Drive Wait For",
+      description: "Wait for a drive condition.",
+      inputSchema: DriveWaitForInputSchema,
+      outputSchema: envelope(DriveWaitForOutputSchema),
+      corePath: "/drive/wait_for"
+    }
+  },
+  {
+    name: "drive.tab_list",
+    config: {
+      title: "Drive Tab List",
+      description: "List browser tabs.",
+      inputSchema: DriveTabListInputSchema,
+      outputSchema: envelope(DriveTabListOutputSchema),
+      corePath: "/drive/tab_list"
+    }
+  },
+  {
+    name: "drive.tab_activate",
+    config: {
+      title: "Drive Tab Activate",
+      description: "Activate a browser tab.",
+      inputSchema: DriveTabActivateInputSchema,
+      outputSchema: envelope(DriveTabActivateOutputSchema),
+      corePath: "/drive/tab_activate"
+    }
+  },
+  {
+    name: "drive.tab_close",
+    config: {
+      title: "Drive Tab Close",
+      description: "Close a browser tab.",
+      inputSchema: DriveTabCloseInputSchema,
+      outputSchema: envelope(DriveTabCloseOutputSchema),
+      corePath: "/drive/tab_close"
+    }
+  },
+  {
+    name: "inspect.dom_snapshot",
+    config: {
+      title: "Inspect DOM Snapshot",
+      description: "Capture a DOM snapshot.",
+      inputSchema: InspectDomSnapshotInputSchema,
+      outputSchema: envelope(InspectDomSnapshotOutputSchema),
+      corePath: "/inspect/dom_snapshot"
+    }
+  },
+  {
+    name: "inspect.dom_diff",
+    config: {
+      title: "Inspect DOM Diff",
+      description: "Compare recent DOM snapshots.",
+      inputSchema: InspectDomDiffInputSchema,
+      outputSchema: envelope(InspectDomDiffOutputSchema),
+      corePath: "/inspect/dom_diff"
+    }
+  },
+  {
+    name: "inspect.find",
+    config: {
+      title: "Inspect Find",
+      description: "Find elements in the accessibility tree and return refs.",
+      inputSchema: InspectFindInputSchema,
+      outputSchema: envelope(InspectFindOutputSchema),
+      corePath: "/inspect/find"
+    }
+  },
+  {
+    name: "inspect.extract_content",
+    config: {
+      title: "Inspect Extract Content",
+      description: "Extract main content as markdown or text.",
+      inputSchema: InspectExtractContentInputSchema,
+      outputSchema: envelope(InspectExtractContentOutputSchema),
+      corePath: "/inspect/extract_content"
+    }
+  },
+  {
+    name: "inspect.page_state",
+    config: {
+      title: "Inspect Page State",
+      description: "Capture form, storage, and cookie state.",
+      inputSchema: InspectPageStateInputSchema,
+      outputSchema: envelope(InspectPageStateOutputSchema),
+      corePath: "/inspect/page_state"
+    }
+  },
+  {
+    name: "inspect.console_list",
+    config: {
+      title: "Inspect Console List",
+      description: "List console entries.",
+      inputSchema: InspectConsoleListInputSchema,
+      outputSchema: envelope(InspectConsoleListOutputSchema),
+      corePath: "/inspect/console_list"
+    }
+  },
+  {
+    name: "inspect.network_har",
+    config: {
+      title: "Inspect Network HAR",
+      description: "Capture network HAR data.",
+      inputSchema: InspectNetworkHarInputSchema,
+      outputSchema: envelope(InspectNetworkHarOutputSchema),
+      corePath: "/inspect/network_har"
+    }
+  },
+  {
+    name: "inspect.evaluate",
+    config: {
+      title: "Inspect Evaluate",
+      description: "Evaluate an expression in the target.",
+      inputSchema: InspectEvaluateInputSchema,
+      outputSchema: envelope(InspectEvaluateOutputSchema),
+      corePath: "/inspect/evaluate"
+    }
+  },
+  {
+    name: "inspect.performance_metrics",
+    config: {
+      title: "Inspect Performance Metrics",
+      description: "Collect performance metrics.",
+      inputSchema: InspectPerformanceMetricsInputSchema,
+      outputSchema: envelope(InspectPerformanceMetricsOutputSchema),
+      corePath: "/inspect/performance_metrics"
+    }
+  },
+  {
+    name: "artifacts.screenshot",
+    config: {
+      title: "Artifacts Screenshot",
+      description: "Capture a screenshot artifact.",
+      inputSchema: ArtifactsScreenshotInputSchema,
+      outputSchema: envelope(ArtifactsScreenshotOutputSchema),
+      corePath: "/artifacts/screenshot"
+    }
+  },
+  {
+    name: "diagnostics.doctor",
+    config: {
+      title: "Diagnostics Doctor",
+      description: "Run diagnostics checks.",
+      inputSchema: DiagnosticsDoctorInputSchema,
+      outputSchema: envelope(DiagnosticsDoctorOutputSchema),
+      corePath: "/diagnostics/doctor"
+    }
+  }
+];
+var createToolHandler = (client, corePath) => {
+  return (async (args, _extra) => {
+    void _extra;
+    try {
+      const envelopeResult = await client.post(corePath, args);
+      return toToolResult(envelopeResult);
+    } catch (error) {
+      const parsed = ErrorEnvelopeSchema.safeParse(error);
+      if (parsed.success) {
+        return toToolResult(parsed.data);
+      }
+      return toToolResult(toInternalErrorEnvelope(error));
+    }
+  });
+};
+var registerBrowserBridgeTools = (server, client) => {
+  for (const tool of TOOL_DEFINITIONS) {
+    server.registerTool(
+      tool.name,
+      {
+        title: tool.config.title,
+        description: tool.config.description,
+        inputSchema: tool.config.inputSchema,
+        outputSchema: tool.config.outputSchema
+      },
+      createToolHandler(client, tool.config.corePath)
+    );
+  }
+};
+
+// 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 DEFAULT_SERVER_NAME = "browser-bridge";
+var DEFAULT_SERVER_VERSION = "0.0.0";
+var createMcpServer = (options = {}) => {
+  const server = new import_mcp.McpServer({
+    name: options.name ?? DEFAULT_SERVER_NAME,
+    version: options.version ?? DEFAULT_SERVER_VERSION
+  });
+  const client = options.coreClient ?? createCoreClient(options);
+  registerBrowserBridgeTools(server, client);
+  return { server, client };
+};
+var startMcpServer = async (options = {}) => {
+  const handle = createMcpServer(options);
+  const transport = new import_stdio.StdioServerTransport();
+  await handle.server.connect(transport);
+  return { ...handle, transport };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startCoreServer,
+  startMcpServer
+});
+//# sourceMappingURL=api.js.map