@btraut/browser-bridge 0.12.1 → 0.13.1

package/dist/index.js

@@ -28,6 +28,7 @@ var import_commander = require("commander");
 
 // packages/shared/src/core-readiness.ts
 var import_promises = require("node:timers/promises");
+var import_node_net = require("node:net");
 
 // packages/shared/src/logging.ts
 var import_node_fs2 = require("node:fs");
@@ -45,9 +46,49 @@ var ENV_CORE_PORT = "BROWSER_BRIDGE_CORE_PORT";
 var ENV_VISION_PORT = "BROWSER_VISION_CORE_PORT";
 var ENV_ISOLATED_MODE = "BROWSER_BRIDGE_ISOLATED_MODE";
 var ENV_VISION_ISOLATED_MODE = "BROWSER_VISION_ISOLATED_MODE";
+var ENV_BRIDGE_CWD = "BROWSER_BRIDGE_CWD";
+var ENV_PROCESS_PWD = "PWD";
+var ENV_PROCESS_INIT_CWD = "INIT_CWD";
+var ENV_PROCESS_HOME = "HOME";
 var RUNTIME_METADATA_RELATIVE_PATH = ".context/browser-bridge/dev.json";
 var DEFAULT_LOG_DIRECTORY_RELATIVE_PATH = ".context/logs/browser-bridge";
-var resolveCwd = (cwd) => (0, import_node_path.resolve)(cwd ?? process.cwd());
+var normalizeCandidatePath = (value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  return (0, import_node_path.resolve)(trimmed);
+};
+var resolveCwd = (cwd) => {
+  const explicit = normalizeCandidatePath(cwd);
+  if (explicit) {
+    return explicit;
+  }
+  const envExplicit = normalizeCandidatePath(process.env[ENV_BRIDGE_CWD]);
+  if (envExplicit) {
+    return envExplicit;
+  }
+  const processCwd = normalizeCandidatePath(process.cwd());
+  if (processCwd && processCwd !== "/") {
+    return processCwd;
+  }
+  const processPwd = normalizeCandidatePath(process.env[ENV_PROCESS_PWD]);
+  if (processPwd && processPwd !== "/") {
+    return processPwd;
+  }
+  const initCwd = normalizeCandidatePath(process.env[ENV_PROCESS_INIT_CWD]);
+  if (initCwd && initCwd !== "/") {
+    return initCwd;
+  }
+  const home = normalizeCandidatePath(process.env[ENV_PROCESS_HOME]);
+  if (home) {
+    return home;
+  }
+  return processCwd ?? (0, import_node_path.resolve)(".");
+};
 var resolveOptionalPath = (cwd, value) => {
   if (!value) {
     return void 0;
@@ -192,8 +233,8 @@ var sanitizeMetadata = (raw) => {
     updated_at: updatedAt
   };
 };
-var findGitRoot = (cwd = process.cwd()) => {
-  let current = (0, import_node_path.resolve)(cwd);
+var findGitRoot = (cwd) => {
+  let current = resolveCwd(cwd);
   while (true) {
     if ((0, import_node_fs.existsSync)((0, import_node_path.join)(current, ".git"))) {
       return current;
@@ -564,6 +605,27 @@ var DEFAULT_HEALTH_RETRY_MS = 250;
 var DEFAULT_HEALTH_ATTEMPTS = 20;
 var DEFAULT_HEALTH_TIMEOUT_MS = 2e3;
 var DEFAULT_HEALTH_BUDGET_MS = 15e3;
+var DEFAULT_PORT_REACHABILITY_TIMEOUT_MS = 300;
+var isPortReachableDefault = async (runtime) => {
+  return await new Promise((resolve4) => {
+    const socket = new import_node_net.Socket();
+    let settled = false;
+    const finish = (reachable) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve4(reachable);
+    };
+    socket.setTimeout(DEFAULT_PORT_REACHABILITY_TIMEOUT_MS);
+    socket.once("connect", () => finish(true));
+    socket.once("timeout", () => finish(false));
+    socket.once("error", () => finish(false));
+    socket.connect(runtime.port, runtime.host);
+  });
+};
 var resolveTimeoutMs = (timeoutMs) => {
   const candidate = timeoutMs ?? (process.env.BROWSER_BRIDGE_CORE_TIMEOUT_MS ? Number.parseInt(process.env.BROWSER_BRIDGE_CORE_TIMEOUT_MS, 10) : process.env.BROWSER_VISION_CORE_TIMEOUT_MS ? Number.parseInt(process.env.BROWSER_VISION_CORE_TIMEOUT_MS, 10) : void 0);
   if (candidate === void 0 || candidate === null) {
@@ -629,57 +691,71 @@ var createCoreReadinessController = (options = {}) => {
     baseUrl = `http://${runtime.host}:${runtime.port}`;
   };
   const checkHealth = async () => {
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), healthTimeoutMs);
+    for (const method of ["POST", "GET"]) {
       try {
-        let response;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), healthTimeoutMs);
         try {
-          response = await fetchImpl(`${baseUrl}/health`, {
-            method: "GET",
-            signal: controller.signal
-          });
-        } catch (error) {
-          if (controller.signal.aborted || error instanceof Error && error.name === "AbortError") {
-            logger.warn(`${logPrefix}.health.timeout`, {
+          let response;
+          try {
+            response = await fetchImpl(`${baseUrl}/health`, {
+              method,
+              signal: controller.signal
+            });
+          } catch (error) {
+            if (controller.signal.aborted || error instanceof Error && error.name === "AbortError") {
+              logger.warn(`${logPrefix}.health.timeout`, {
+                base_url: baseUrl,
+                method,
+                timeout_ms: healthTimeoutMs
+              });
+              continue;
+            }
+            logger.warn(`${logPrefix}.health.fetch_failed`, {
               base_url: baseUrl,
-              timeout_ms: healthTimeoutMs
+              method,
+              error
             });
-            return false;
+            throw error;
+          }
+          if (!response.ok) {
+            logger.warn(`${logPrefix}.health.non_ok`, {
+              base_url: baseUrl,
+              method,
+              status: response.status
+            });
+            continue;
+          }
+          const data = await response.json().catch(() => null);
+          const ok = Boolean(data?.ok);
+          if (ok) {
+            if (method === "GET") {
+              logger.info(`${logPrefix}.health.compat_probe`, {
+                base_url: baseUrl,
+                method
+              });
+            }
+            return true;
           }
-          logger.warn(`${logPrefix}.health.fetch_failed`, {
-            base_url: baseUrl,
-            error
-          });
-          throw error;
-        }
-        if (!response.ok) {
-          logger.warn(`${logPrefix}.health.non_ok`, {
-            base_url: baseUrl,
-            status: response.status
-          });
-          return false;
-        }
-        const data = await response.json().catch(() => null);
-        const ok = Boolean(data?.ok);
-        if (!ok) {
           logger.warn(`${logPrefix}.health.not_ready`, {
-            base_url: baseUrl
+            base_url: baseUrl,
+            method
           });
+        } finally {
+          clearTimeout(timeout);
         }
-        return ok;
-      } finally {
-        clearTimeout(timeout);
+      } catch (error) {
+        logger.warn(`${logPrefix}.health.error`, {
+          base_url: baseUrl,
+          method,
+          error
+        });
       }
-    } catch (error) {
-      logger.warn(`${logPrefix}.health.error`, {
-        base_url: baseUrl,
-        error
-      });
-      return false;
     }
+    return false;
   };
   const ensureCoreRunning = async () => {
+    const portReachabilityCheck = options.portReachabilityCheck ?? isPortReachableDefault;
     refreshRuntime();
     if (await checkHealth()) {
       logger.debug(`${logPrefix}.ensure_ready.already_running`, {
@@ -720,6 +796,21 @@ var createCoreReadinessController = (options = {}) => {
       health_budget_ms: healthBudgetMs,
       health_timeout_ms: healthTimeoutMs
     });
+    let portOccupied = false;
+    try {
+      portOccupied = await portReachabilityCheck(runtime);
+    } catch (error) {
+      logger.warn(`${logPrefix}.ensure_ready.port_probe_failed`, {
+        host: runtime.host,
+        port: runtime.port,
+        error
+      });
+    }
+    if (portOccupied) {
+      throw new Error(
+        `Core daemon failed to start on ${runtime.host}:${runtime.port}. A process is already listening on this port but did not pass Browser Bridge health checks. Retry with --no-daemon to reuse it, or enable isolated mode (BROWSER_BRIDGE_ISOLATED_MODE=1) for per-worktree ports.`
+      );
+    }
     throw new Error(
       `Core daemon failed to start on ${runtime.host}:${runtime.port}.`
     );
@@ -750,9 +841,24 @@ var createCoreReadinessController = (options = {}) => {
   };
 };
 
+// packages/shared/src/contract-version.ts
+var HTTP_CONTRACT_VERSION_HEADER = "x-browser-bridge-contract-version";
+var HTTP_CONTRACT_VERSION = "2026-02-17.1";
+
 // packages/shared/src/errors.ts
+var import_zod2 = require("zod");
+
+// packages/shared/src/retry-policy.ts
 var import_zod = require("zod");
-var ErrorCodeSchema = import_zod.z.enum([
+var RetryHintSchema = import_zod.z.object({
+  retryable: import_zod.z.boolean(),
+  reason: import_zod.z.string().optional(),
+  retry_after_ms: import_zod.z.number().int().nonnegative().optional(),
+  max_attempts: import_zod.z.number().int().positive().optional()
+});
+
+// packages/shared/src/errors.ts
+var ErrorCodeSchema = import_zod2.z.enum([
   "UNKNOWN",
   "INVALID_ARGUMENT",
   "NOT_FOUND",
@@ -785,32 +891,59 @@ var ErrorCodeSchema = import_zod.z.enum([
   "EVALUATION_FAILED",
   "ARTIFACT_IO_ERROR"
 ]);
-var ErrorInfoSchema = import_zod.z.object({
+var PublicErrorCodeSchema = import_zod2.z.enum([
+  "UNKNOWN",
+  "INVALID_ARGUMENT",
+  "NOT_FOUND",
+  "ALREADY_EXISTS",
+  "FAILED_PRECONDITION",
+  "UNAUTHORIZED",
+  "FORBIDDEN",
+  "CONFLICT",
+  "TIMEOUT",
+  "CANCELLED",
+  "UNAVAILABLE",
+  "RATE_LIMITED",
+  "NOT_IMPLEMENTED",
+  "INTERNAL"
+]);
+var PublicErrorDetailsSchema = import_zod2.z.object({
+  legacy_code: ErrorCodeSchema.optional(),
+  reason: import_zod2.z.string().optional(),
+  resource: import_zod2.z.string().optional(),
+  field: import_zod2.z.string().optional(),
+  session_id: import_zod2.z.string().optional(),
+  tab_id: import_zod2.z.number().finite().optional(),
+  retry_after_ms: import_zod2.z.number().finite().optional(),
+  next_step: import_zod2.z.string().optional()
+}).catchall(import_zod2.z.unknown());
+var ErrorInfoSchema = import_zod2.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()
+  message: import_zod2.z.string(),
+  retryable: import_zod2.z.boolean(),
+  retry: RetryHintSchema.optional(),
+  details: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
 });
-var ErrorEnvelopeSchema = import_zod.z.object({
-  ok: import_zod.z.literal(false),
+var ErrorEnvelopeSchema = import_zod2.z.object({
+  ok: import_zod2.z.literal(false),
   error: ErrorInfoSchema
 });
-var successEnvelopeSchema = (result) => import_zod.z.object({
-  ok: import_zod.z.literal(true),
+var successEnvelopeSchema = (result) => import_zod2.z.object({
+  ok: import_zod2.z.literal(true),
   result
 });
 
 // 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 import_zod3 = require("zod");
+var LocatorRoleSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  value: import_zod3.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(),
+var LocatorSchema = import_zod3.z.object({
+  ref: import_zod3.z.string().min(1).optional(),
+  testid: import_zod3.z.string().min(1).optional(),
+  css: import_zod3.z.string().min(1).optional(),
+  text: import_zod3.z.string().min(1).optional(),
   role: LocatorRoleSchema.optional()
 }).refine(
   (value) => Boolean(
@@ -820,12 +953,12 @@ var LocatorSchema = import_zod2.z.object({
     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 OpResultSchema = import_zod3.z.object({
+  ok: import_zod3.z.literal(true),
+  message: import_zod3.z.string().optional(),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
-var SessionStateSchema = import_zod2.z.enum([
+var SessionStateSchema = import_zod3.z.enum([
   "INIT",
   "DRIVE_READY",
   "INSPECT_READY",
@@ -835,269 +968,270 @@ var SessionStateSchema = import_zod2.z.enum([
   "BROKEN",
   "CLOSED"
 ]);
-var SessionInfoSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string(),
+var SessionInfoSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string(),
   state: SessionStateSchema,
-  created_at: import_zod2.z.string().datetime().optional()
+  created_at: import_zod3.z.string().datetime().optional()
 });
-var SessionPlaneStatusSchema = import_zod2.z.object({
-  connected: import_zod2.z.boolean(),
-  last_seen_at: import_zod2.z.string().datetime().optional(),
+var SessionPlaneStatusSchema = import_zod3.z.object({
+  connected: import_zod3.z.boolean(),
+  last_seen_at: import_zod3.z.string().datetime().optional(),
   error: ErrorInfoSchema.optional()
 });
-var SessionStatusSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string(),
+var SessionStatusSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string(),
   state: SessionStateSchema,
   drive: SessionPlaneStatusSchema.optional(),
   inspect: SessionPlaneStatusSchema.optional(),
-  updated_at: import_zod2.z.string().datetime().optional()
+  updated_at: import_zod3.z.string().datetime().optional()
 });
-var RecoverResultSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string(),
-  recovered: import_zod2.z.boolean(),
+var RecoverResultSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string(),
+  recovered: import_zod3.z.boolean(),
   state: SessionStateSchema,
-  message: import_zod2.z.string().optional()
+  message: import_zod3.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 DiagnosticCheckSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  ok: import_zod3.z.boolean(),
+  message: import_zod3.z.string().optional(),
+  details: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
 });
-var DiagnosticsRuntimeEndpointSchema = import_zod2.z.object({
-  host: import_zod2.z.string().optional(),
-  port: import_zod2.z.number().finite().optional(),
-  base_url: import_zod2.z.string().optional(),
-  host_source: import_zod2.z.string().optional(),
-  port_source: import_zod2.z.string().optional(),
-  metadata_path: import_zod2.z.string().optional(),
-  isolated_mode: import_zod2.z.boolean().optional()
+var DiagnosticsRuntimeEndpointSchema = import_zod3.z.object({
+  host: import_zod3.z.string().optional(),
+  port: import_zod3.z.number().finite().optional(),
+  base_url: import_zod3.z.string().optional(),
+  host_source: import_zod3.z.string().optional(),
+  port_source: import_zod3.z.string().optional(),
+  metadata_path: import_zod3.z.string().optional(),
+  isolated_mode: import_zod3.z.boolean().optional()
 });
-var DiagnosticsRuntimeProcessSchema = import_zod2.z.object({
-  component: import_zod2.z.enum(["cli", "mcp", "core"]).optional(),
-  version: import_zod2.z.string().optional(),
-  pid: import_zod2.z.number().int().positive().optional(),
-  node_version: import_zod2.z.string().optional(),
-  binary_path: import_zod2.z.string().optional(),
-  argv_entry: import_zod2.z.string().optional()
+var DiagnosticsRuntimeProcessSchema = import_zod3.z.object({
+  component: import_zod3.z.enum(["cli", "mcp", "core"]).optional(),
+  version: import_zod3.z.string().optional(),
+  pid: import_zod3.z.number().int().positive().optional(),
+  node_version: import_zod3.z.string().optional(),
+  binary_path: import_zod3.z.string().optional(),
+  argv_entry: import_zod3.z.string().optional()
 });
-var DiagnosticsRuntimeCallerSchema = import_zod2.z.object({
+var DiagnosticsRuntimeCallerSchema = import_zod3.z.object({
   endpoint: DiagnosticsRuntimeEndpointSchema.optional(),
   process: DiagnosticsRuntimeProcessSchema.optional()
 });
-var DiagnosticsRuntimeContextSchema = import_zod2.z.object({
+var DiagnosticsRuntimeContextSchema = import_zod3.z.object({
   caller: DiagnosticsRuntimeCallerSchema.optional(),
-  core: import_zod2.z.object({
+  core: import_zod3.z.object({
     endpoint: DiagnosticsRuntimeEndpointSchema.optional(),
     process: DiagnosticsRuntimeProcessSchema.optional()
   }).optional(),
-  extension: import_zod2.z.object({
-    version: import_zod2.z.string().optional(),
+  extension: import_zod3.z.object({
+    version: import_zod3.z.string().optional(),
+    protocol_version: import_zod3.z.string().optional(),
+    capability_negotiated: import_zod3.z.boolean().optional(),
+    capabilities: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.boolean()).optional(),
     endpoint: DiagnosticsRuntimeEndpointSchema.optional(),
-    port_source: import_zod2.z.enum(["default", "storage"]).optional()
+    port_source: import_zod3.z.enum(["default", "storage"]).optional()
   }).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(),
-  sessions: import_zod2.z.object({
-    count: import_zod2.z.number().finite().optional(),
-    max_age_ms: import_zod2.z.number().finite().optional(),
-    max_idle_ms: import_zod2.z.number().finite().optional()
+var DiagnosticReportSchema = import_zod3.z.object({
+  ok: import_zod3.z.boolean(),
+  session_id: import_zod3.z.string().optional(),
+  checks: import_zod3.z.array(DiagnosticCheckSchema).optional(),
+  sessions: import_zod3.z.object({
+    count: import_zod3.z.number().finite().optional(),
+    max_age_ms: import_zod3.z.number().finite().optional(),
+    max_idle_ms: import_zod3.z.number().finite().optional()
   }).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()
+  extension: import_zod3.z.object({
+    connected: import_zod3.z.boolean().optional(),
+    version: import_zod3.z.string().optional(),
+    last_seen_at: import_zod3.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(),
+  debugger: import_zod3.z.object({
+    attached: import_zod3.z.boolean().optional(),
+    idle_timeout_ms: import_zod3.z.number().finite().optional(),
+    console_buffer_size: import_zod3.z.number().finite().optional(),
+    network_buffer_size: import_zod3.z.number().finite().optional(),
     last_error: ErrorInfoSchema.optional()
   }).optional(),
-  artifacts: import_zod2.z.object({
-    root_dir: import_zod2.z.string().optional()
+  artifacts: import_zod3.z.object({
+    root_dir: import_zod3.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(),
+  recovery: import_zod3.z.object({
+    last_attempt: import_zod3.z.object({
+      session_id: import_zod3.z.string(),
+      recovered: import_zod3.z.boolean(),
       state: SessionStateSchema,
-      message: import_zod2.z.string().optional(),
-      at: import_zod2.z.string()
+      message: import_zod3.z.string().optional(),
+      at: import_zod3.z.string()
     }).optional(),
-    attempts: import_zod2.z.array(
-      import_zod2.z.object({
-        session_id: import_zod2.z.string(),
-        recovered: import_zod2.z.boolean(),
+    attempts: import_zod3.z.array(
+      import_zod3.z.object({
+        session_id: import_zod3.z.string(),
+        recovered: import_zod3.z.boolean(),
         state: SessionStateSchema,
-        message: import_zod2.z.string().optional(),
-        at: import_zod2.z.string()
+        message: import_zod3.z.string().optional(),
+        at: import_zod3.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()
+    success_count: import_zod3.z.number().finite().optional(),
+    failure_count: import_zod3.z.number().finite().optional(),
+    success_rate: import_zod3.z.number().finite().optional(),
+    recent_failure_count: import_zod3.z.number().finite().optional(),
+    loop_detected: import_zod3.z.boolean().optional()
   }).optional(),
-  warnings: import_zod2.z.array(import_zod2.z.string()).optional(),
-  notes: import_zod2.z.array(import_zod2.z.string()).optional(),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional(),
+  notes: import_zod3.z.array(import_zod3.z.string()).optional(),
   runtime: DiagnosticsRuntimeContextSchema.optional()
 });
-var SessionIdSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1)
+var SessionIdSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1)
 });
-var SessionCreateInputSchema = import_zod2.z.object({}).strict().default({});
+var SessionCreateInputSchema = import_zod3.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 SessionCloseOutputSchema = import_zod3.z.object({
+  ok: import_zod3.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 DriveWaitConditionSchema = import_zod3.z.object({
+  kind: import_zod3.z.enum(["locator_visible", "text_present", "url_matches"]),
+  value: import_zod3.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 DriveNavigateInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1).optional(),
+  url: import_zod3.z.string().min(1),
+  tab_id: import_zod3.z.number().finite().optional(),
+  wait: import_zod3.z.enum(["none", "domcontentloaded"]).default("domcontentloaded")
+});
+var DriveNavigateOutputSchema = OpResultSchema.extend({
+  session_id: import_zod3.z.string().min(1)
 });
-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 DriveGoBackInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  tab_id: import_zod3.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 DriveGoForwardInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  tab_id: import_zod3.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),
+var DriveClickInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
   locator: LocatorSchema,
-  tab_id: import_zod2.z.number().finite().optional(),
-  click_count: import_zod2.z.number().finite().optional()
+  tab_id: import_zod3.z.number().finite().optional(),
+  click_count: import_zod3.z.number().finite().optional()
 });
 var DriveClickOutputSchema = OpResultSchema;
-var DriveHoverInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var DriveHoverInputSchema = import_zod3.z.object({
+  session_id: import_zod3.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()
+  delay_ms: import_zod3.z.number().min(0).max(1e4).optional(),
+  tab_id: import_zod3.z.number().finite().optional()
 });
-var DriveHoverOutputSchema = import_zod2.z.object({
-  format: import_zod2.z.literal("html"),
-  snapshot: import_zod2.z.string()
+var DriveHoverOutputSchema = import_zod3.z.object({
+  format: import_zod3.z.literal("html"),
+  snapshot: import_zod3.z.string()
 });
-var DriveSelectInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var DriveSelectInputSchema = import_zod3.z.object({
+  session_id: import_zod3.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()
+  value: import_zod3.z.string().min(1).optional(),
+  text: import_zod3.z.string().min(1).optional(),
+  index: import_zod3.z.number().int().min(0).optional(),
+  tab_id: import_zod3.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),
+var DriveTypeInputSchema = import_zod3.z.object({
+  session_id: import_zod3.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)
+  text: import_zod3.z.string().min(1),
+  tab_id: import_zod3.z.number().finite().optional(),
+  clear: import_zod3.z.boolean().default(false),
+  submit: import_zod3.z.boolean().default(false)
 });
 var DriveTypeOutputSchema = OpResultSchema;
-var DriveFillFormFieldSchema = import_zod2.z.object({
-  selector: import_zod2.z.string().min(1).optional(),
+var DriveFillFormFieldSchema = import_zod3.z.object({
+  selector: import_zod3.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)
+  value: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.boolean()]),
+  type: import_zod3.z.enum(["auto", "text", "select", "checkbox", "radio", "contentEditable"]).default("auto"),
+  submit: import_zod3.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 DriveFillFormInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  fields: import_zod3.z.array(DriveFillFormFieldSchema).min(1),
+  tab_id: import_zod3.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 DriveFillFormOutputSchema = import_zod3.z.object({
+  filled: import_zod3.z.number().finite(),
+  attempted: import_zod3.z.number().finite(),
+  errors: import_zod3.z.array(import_zod3.z.string()).optional()
 });
-var DriveDragInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var DriveDragInputSchema = import_zod3.z.object({
+  session_id: import_zod3.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()
+  steps: import_zod3.z.number().min(1).max(50).default(12),
+  tab_id: import_zod3.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 DriveHandleDialogInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  action: import_zod3.z.enum(["accept", "dismiss"]),
+  promptText: import_zod3.z.string().optional(),
+  tab_id: import_zod3.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()
+  promptText: import_zod3.z.string().optional(),
+  tab_id: import_zod3.z.number().finite().optional()
 });
 var DialogAcceptOutputSchema = OpResultSchema;
 var DialogDismissInputSchema = SessionIdSchema.extend({
-  tab_id: import_zod2.z.number().finite().optional()
+  tab_id: import_zod3.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 DriveKeyModifiersSchema = import_zod3.z.object({
+  ctrl: import_zod3.z.boolean().optional(),
+  alt: import_zod3.z.boolean().optional(),
+  shift: import_zod3.z.boolean().optional(),
+  meta: import_zod3.z.boolean().optional()
 });
-var DriveKeyPressInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
-  key: import_zod2.z.string().min(1),
+var DriveKeyPressInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  key: import_zod3.z.string().min(1),
   modifiers: DriveKeyModifiersSchema.optional(),
-  tab_id: import_zod2.z.number().finite().optional()
+  tab_id: import_zod3.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 DriveKeyModifierSchema = import_zod3.z.enum(["ctrl", "alt", "shift", "meta"]);
+var DriveKeyInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  key: import_zod3.z.string().min(1),
+  modifiers: import_zod3.z.array(DriveKeyModifierSchema).optional(),
+  repeat: import_zod3.z.number().int().min(1).max(50).optional(),
+  tab_id: import_zod3.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()
+var DriveScrollInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  delta_x: import_zod3.z.number().finite().optional(),
+  delta_y: import_zod3.z.number().finite().optional(),
+  top: import_zod3.z.number().finite().optional(),
+  left: import_zod3.z.number().finite().optional(),
+  behavior: import_zod3.z.enum(["auto", "smooth"]).optional(),
+  tab_id: import_zod3.z.number().finite().optional()
 }).refine(
   (value) => value.delta_x !== void 0 || value.delta_y !== void 0 || value.top !== void 0 || value.left !== void 0,
   {
@@ -1106,245 +1240,245 @@ var DriveScrollInputSchema = import_zod2.z.object({
   }
 );
 var DriveScrollOutputSchema = OpResultSchema;
-var DriveWaitForInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var DriveWaitForInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
   condition: DriveWaitConditionSchema,
-  timeout_ms: import_zod2.z.number().finite().optional(),
-  tab_id: import_zod2.z.number().finite().optional()
+  timeout_ms: import_zod3.z.number().finite().optional(),
+  tab_id: import_zod3.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 DriveTabInfoSchema = import_zod3.z.object({
+  tab_id: import_zod3.z.number().finite(),
+  window_id: import_zod3.z.number().finite(),
+  url: import_zod3.z.string().min(1),
+  title: import_zod3.z.string(),
+  active: import_zod3.z.boolean().optional(),
+  last_active_at: import_zod3.z.string().datetime().optional()
 });
 var DriveTabListInputSchema = SessionIdSchema;
-var DriveTabListOutputSchema = import_zod2.z.object({
-  tabs: import_zod2.z.array(DriveTabInfoSchema)
+var DriveTabListOutputSchema = import_zod3.z.object({
+  tabs: import_zod3.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 DriveTabActivateInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  tab_id: import_zod3.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 DriveTabCloseInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  tab_id: import_zod3.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 InspectDomFormatSchema = import_zod3.z.enum(["ax", "html"]);
+var InspectConsistencySchema = import_zod3.z.enum(["best_effort", "quiesce"]);
+var TargetHintSchema = import_zod3.z.object({
+  url: import_zod3.z.string().min(1).optional(),
+  title: import_zod3.z.string().min(1).optional(),
+  last_active_at: import_zod3.z.string().optional(),
+  lastActiveAt: import_zod3.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 FormFieldInfoSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  type: import_zod3.z.string(),
+  value: import_zod3.z.string(),
+  options: import_zod3.z.array(import_zod3.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 FormInfoSchema = import_zod3.z.object({
+  selector: import_zod3.z.string(),
+  action: import_zod3.z.string().optional(),
+  method: import_zod3.z.string().optional(),
+  fields: import_zod3.z.array(FormFieldInfoSchema)
 });
-var StorageEntrySchema = import_zod2.z.object({
-  key: import_zod2.z.string(),
-  value: import_zod2.z.string()
+var StorageEntrySchema = import_zod3.z.object({
+  key: import_zod3.z.string(),
+  value: import_zod3.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 PageStateSchema = import_zod3.z.object({
+  forms: import_zod3.z.array(FormInfoSchema),
+  localStorage: import_zod3.z.array(StorageEntrySchema),
+  sessionStorage: import_zod3.z.array(StorageEntrySchema),
+  cookies: import_zod3.z.array(StorageEntrySchema),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
-var DomSnapshotSchema = import_zod2.z.object({
+var DomSnapshotSchema = import_zod3.z.object({
   format: InspectDomFormatSchema,
-  snapshot: import_zod2.z.unknown()
+  snapshot: import_zod3.z.unknown()
 }).passthrough();
-var InspectDomSnapshotInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1),
+var InspectDomSnapshotInputSchema = import_zod3.z.object({
+  session_id: import_zod3.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),
+  interactive: import_zod3.z.boolean().default(false),
+  compact: import_zod3.z.boolean().default(false),
   // Used primarily to bound large AX trees for LLM/agent consumption.
   // CLI passes this as a string, so coerce for convenience.
-  max_nodes: import_zod2.z.coerce.number().int().positive().max(5e4).optional(),
-  selector: import_zod2.z.string().min(1).optional(),
+  max_nodes: import_zod3.z.coerce.number().int().positive().max(5e4).optional(),
+  selector: import_zod3.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 DomDiffResultSchema = import_zod3.z.object({
+  added: import_zod3.z.array(import_zod3.z.string()),
+  removed: import_zod3.z.array(import_zod3.z.string()),
+  changed: import_zod3.z.array(import_zod3.z.string()),
+  summary: import_zod3.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(),
+  kind: import_zod3.z.literal("role"),
+  role: import_zod3.z.string().min(1),
+  name: import_zod3.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),
+  kind: import_zod3.z.literal("text"),
+  text: import_zod3.z.string().min(1),
   target: TargetHintSchema.optional()
 });
 var InspectFindLabelInputSchema = SessionIdSchema.extend({
-  kind: import_zod2.z.literal("label"),
-  label: import_zod2.z.string().min(1),
+  kind: import_zod3.z.literal("label"),
+  label: import_zod3.z.string().min(1),
   target: TargetHintSchema.optional()
 });
-var InspectFindInputSchema = import_zod2.z.discriminatedUnion("kind", [
+var InspectFindInputSchema = import_zod3.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 InspectFindMatchSchema = import_zod3.z.object({
+  ref: import_zod3.z.string(),
+  role: import_zod3.z.string().optional(),
+  name: import_zod3.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 InspectFindOutputSchema = import_zod3.z.object({
+  matches: import_zod3.z.array(InspectFindMatchSchema),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
 var InspectPageStateInputSchema = SessionIdSchema.extend({
   target: TargetHintSchema.optional()
 });
 var InspectPageStateOutputSchema = PageStateSchema;
-var InspectExtractContentFormatSchema = import_zod2.z.enum([
+var InspectExtractContentFormatSchema = import_zod3.z.enum([
   "markdown",
   "text",
   "article_json"
 ]);
 var InspectExtractContentInputSchema = SessionIdSchema.extend({
   format: InspectExtractContentFormatSchema.default("markdown"),
-  include_metadata: import_zod2.z.boolean().default(true),
+  include_metadata: import_zod3.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 InspectExtractContentOutputSchema = import_zod3.z.object({
+  content: import_zod3.z.string(),
+  title: import_zod3.z.string().optional(),
+  byline: import_zod3.z.string().optional(),
+  excerpt: import_zod3.z.string().optional(),
+  siteName: import_zod3.z.string().optional(),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
 var InspectConsoleListInputSchema = SessionIdSchema.extend({
   target: TargetHintSchema.optional()
 });
-var ConsoleSourceLocationSchema = import_zod2.z.object({
-  url: import_zod2.z.string().optional(),
+var ConsoleSourceLocationSchema = import_zod3.z.object({
+  url: import_zod3.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()
+  line: import_zod3.z.number().int().positive().optional(),
+  column: import_zod3.z.number().int().positive().optional()
 }).passthrough();
-var ConsoleStackFrameSchema = import_zod2.z.object({
-  functionName: import_zod2.z.string().optional(),
-  url: import_zod2.z.string().optional(),
+var ConsoleStackFrameSchema = import_zod3.z.object({
+  functionName: import_zod3.z.string().optional(),
+  url: import_zod3.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()
+  line: import_zod3.z.number().int().positive().optional(),
+  column: import_zod3.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()
+var ConsoleRemoteObjectSchema = import_zod3.z.object({
+  type: import_zod3.z.string().optional(),
+  subtype: import_zod3.z.string().optional(),
+  description: import_zod3.z.string().optional(),
+  value: import_zod3.z.unknown().optional(),
+  unserializableValue: import_zod3.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(),
+var ConsoleEntrySchema = import_zod3.z.object({
+  level: import_zod3.z.string().optional(),
+  text: import_zod3.z.string().optional(),
+  timestamp: import_zod3.z.string().datetime().optional(),
   source: ConsoleSourceLocationSchema.optional(),
-  stack: import_zod2.z.array(ConsoleStackFrameSchema).optional(),
+  stack: import_zod3.z.array(ConsoleStackFrameSchema).optional(),
   exception: ConsoleRemoteObjectSchema.optional(),
-  args: import_zod2.z.array(ConsoleRemoteObjectSchema).optional()
+  args: import_zod3.z.array(ConsoleRemoteObjectSchema).optional()
 }).passthrough();
-var ConsoleListSchema = import_zod2.z.object({
-  entries: import_zod2.z.array(ConsoleEntrySchema)
+var ConsoleListSchema = import_zod3.z.object({
+  entries: import_zod3.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 ArtifactInfoSchema = import_zod3.z.object({
+  artifact_id: import_zod3.z.string(),
+  path: import_zod3.z.string(),
+  mime: import_zod3.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(),
+var InspectEvaluateInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  expression: import_zod3.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()
+var EvaluateResultSchema = import_zod3.z.object({
+  value: import_zod3.z.unknown().optional(),
+  exception: import_zod3.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()
+var PerformanceMetricSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  value: import_zod3.z.number().finite()
 }).passthrough();
-var PerformanceMetricsSchema = import_zod2.z.object({
-  metrics: import_zod2.z.array(PerformanceMetricSchema)
+var PerformanceMetricsSchema = import_zod3.z.object({
+  metrics: import_zod3.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),
-  selector: import_zod2.z.string().min(1).optional(),
-  format: import_zod2.z.enum(["png", "jpeg", "webp"]).default("png"),
-  quality: import_zod2.z.number().min(0).max(100).optional()
+var ArtifactsScreenshotInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1),
+  target: import_zod3.z.enum(["viewport", "full"]).default("viewport"),
+  fullPage: import_zod3.z.boolean().default(false),
+  selector: import_zod3.z.string().min(1).optional(),
+  format: import_zod3.z.enum(["png", "jpeg", "webp"]).default("png"),
+  quality: import_zod3.z.number().min(0).max(100).optional()
 });
 var ArtifactsScreenshotOutputSchema = ArtifactInfoSchema;
-var HealthCheckInputSchema = import_zod2.z.object({});
-var HealthCheckOutputSchema = import_zod2.z.object({
-  started_at: import_zod2.z.string().min(1),
-  uptime_ms: import_zod2.z.number().finite().nonnegative(),
-  memory: import_zod2.z.object({
-    rss: import_zod2.z.number().finite().nonnegative(),
-    heapTotal: import_zod2.z.number().finite().nonnegative(),
-    heapUsed: import_zod2.z.number().finite().nonnegative(),
-    external: import_zod2.z.number().finite().nonnegative(),
-    arrayBuffers: import_zod2.z.number().finite().nonnegative().optional()
+var HealthCheckInputSchema = import_zod3.z.object({});
+var HealthCheckOutputSchema = import_zod3.z.object({
+  started_at: import_zod3.z.string().min(1),
+  uptime_ms: import_zod3.z.number().finite().nonnegative(),
+  memory: import_zod3.z.object({
+    rss: import_zod3.z.number().finite().nonnegative(),
+    heapTotal: import_zod3.z.number().finite().nonnegative(),
+    heapUsed: import_zod3.z.number().finite().nonnegative(),
+    external: import_zod3.z.number().finite().nonnegative(),
+    arrayBuffers: import_zod3.z.number().finite().nonnegative().optional()
   }).passthrough(),
-  sessions: import_zod2.z.object({
-    active: import_zod2.z.number().finite().nonnegative()
+  sessions: import_zod3.z.object({
+    active: import_zod3.z.number().finite().nonnegative()
   }).passthrough(),
-  extension: import_zod2.z.object({
-    connected: import_zod2.z.boolean(),
-    last_seen_at: import_zod2.z.string().min(1).optional()
+  extension: import_zod3.z.object({
+    connected: import_zod3.z.boolean(),
+    last_seen_at: import_zod3.z.string().min(1).optional()
   }).passthrough()
 }).passthrough();
-var DiagnosticsDoctorInputSchema = import_zod2.z.object({
-  session_id: import_zod2.z.string().min(1).optional(),
+var DiagnosticsDoctorInputSchema = import_zod3.z.object({
+  session_id: import_zod3.z.string().min(1).optional(),
   caller: DiagnosticsRuntimeCallerSchema.optional()
 });
 var DiagnosticsDoctorOutputSchema = DiagnosticReportSchema;
 
 // packages/cli/src/cli-output.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // packages/cli/src/core-client.ts
 var import_node_child_process = require("node:child_process");
@@ -1378,6 +1512,7 @@ var createCoreClient = (options = {}) => {
   const fetchImpl = options.fetchImpl ?? fetch;
   const spawnImpl = options.spawnImpl ?? import_node_child_process.spawn;
   const timeoutMs = resolveTimeoutMs2(options.timeoutMs);
+  const componentVersion = process.env.BROWSER_BRIDGE_VERSION ?? process.env.npm_package_version;
   const readiness = createCoreReadinessController({
     host: options.host,
     port: options.port,
@@ -1441,7 +1576,8 @@ startCoreServer({ ${startOptions.join(
         response = await fetchImpl(`${readiness.baseUrl}${requestPath}`, {
           method,
           headers: {
-            "content-type": "application/json"
+            "content-type": "application/json",
+            [HTTP_CONTRACT_VERSION_HEADER]: HTTP_CONTRACT_VERSION
           },
           body: body === void 0 ? void 0 : JSON.stringify(body),
           signal: controller.signal
@@ -1459,6 +1595,12 @@ startCoreServer({ ${startOptions.join(
             code: "TIMEOUT",
             message: `Core request timed out after ${timeoutMs}ms.`,
             retryable: true,
+            retry: {
+              retryable: true,
+              reason: "core_request_timeout",
+              retry_after_ms: 250,
+              max_attempts: 1
+            },
             details: {
               timeout_ms: timeoutMs,
               base_url: readiness.baseUrl,
@@ -1515,7 +1657,29 @@ startCoreServer({ ${startOptions.join(
   const post = async (path9, body) => {
     await readiness.ensureReady();
     readiness.refreshRuntime();
-    return requestJson("POST", path9, body);
+    const payload = path9 === "/diagnostics/doctor" && (!body || typeof body === "object" && !Array.isArray(body)) ? {
+      ...body && typeof body === "object" ? body : {},
+      caller: {
+        endpoint: {
+          host: readiness.runtime.host,
+          port: readiness.runtime.port,
+          base_url: readiness.baseUrl,
+          host_source: readiness.runtime.hostSource,
+          port_source: readiness.runtime.portSource,
+          metadata_path: readiness.runtime.metadataPath,
+          isolated_mode: readiness.runtime.isolatedMode
+        },
+        process: {
+          component: "cli",
+          version: componentVersion,
+          pid: process.pid,
+          node_version: process.version,
+          binary_path: process.execPath,
+          argv_entry: process.argv[1]
+        }
+      }
+    } : body;
+    return requestJson("POST", path9, payload);
   };
   return {
     get baseUrl() {
@@ -1571,7 +1735,7 @@ var toErrorInfo = (error) => {
   if (error instanceof CoreClientError) {
     return error.info;
   }
-  if (error instanceof import_zod3.ZodError) {
+  if (error instanceof import_zod4.ZodError) {
     const [issue] = error.issues;
     return {
       code: "INVALID_ARGUMENT",
@@ -1729,25 +1893,52 @@ var parseNumber2 = (value) => {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : Number.NaN;
 };
+var addDeprecatedDialogAliasWarning = (envelope2, aliasName) => {
+  if (!envelope2.ok || typeof envelope2.result !== "object" || !envelope2.result) {
+    return envelope2;
+  }
+  const warning = `${aliasName} is deprecated; use drive.handle_dialog.`;
+  const result = envelope2.result;
+  const existingWarnings = Array.isArray(result.warnings) ? result.warnings.filter((item) => typeof item === "string") : [];
+  return {
+    ok: true,
+    result: {
+      ...result,
+      warnings: existingWarnings.includes(warning) ? existingWarnings : [...existingWarnings, warning]
+    }
+  };
+};
 var registerDialogCommands = (program2) => {
   const dialog = program2.command("dialog").description("Dialog commands");
-  dialog.command("accept").description("Accept a JavaScript dialog").requiredOption("--session-id <id>", "Session identifier").option("--prompt-text <text>", "Prompt text for prompt() dialogs").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+  dialog.command("accept").description("Deprecated alias for drive handle-dialog --action accept").requiredOption("--session-id <id>", "Session identifier").option("--prompt-text <text>", "Prompt text for prompt() dialogs").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
     await runCommand(command, (client) => {
-      const payload = parseInput(DialogAcceptInputSchema, {
+      const aliasPayload = parseInput(DialogAcceptInputSchema, {
         session_id: options.sessionId,
         promptText: options.promptText,
         tab_id: parseNumber2(options.tabId)
       });
-      return client.post("/dialog/accept", payload);
+      const payload = parseInput(DriveHandleDialogInputSchema, {
+        ...aliasPayload,
+        action: "accept"
+      });
+      return client.post("/drive/handle_dialog", payload).then(
+        (envelope2) => addDeprecatedDialogAliasWarning(envelope2, "dialog.accept")
+      );
     });
   });
-  dialog.command("dismiss").description("Dismiss a JavaScript dialog").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
+  dialog.command("dismiss").description("Deprecated alias for drive handle-dialog --action dismiss").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier").action(async (options, command) => {
     await runCommand(command, (client) => {
-      const payload = parseInput(DialogDismissInputSchema, {
+      const aliasPayload = parseInput(DialogDismissInputSchema, {
         session_id: options.sessionId,
         tab_id: parseNumber2(options.tabId)
       });
-      return client.post("/dialog/dismiss", payload);
+      const payload = parseInput(DriveHandleDialogInputSchema, {
+        ...aliasPayload,
+        action: "dismiss"
+      });
+      return client.post("/drive/handle_dialog", payload).then(
+        (envelope2) => addDeprecatedDialogAliasWarning(envelope2, "dialog.dismiss")
+      );
     });
   });
 };
@@ -1756,26 +1947,9 @@ var registerDialogCommands = (program2) => {
 var registerDiagnosticsCommands = (program2) => {
   const diagnostics = program2.command("diagnostics").description("Diagnostics commands");
   diagnostics.command("doctor").description("Run diagnostics").option("--session-id <id>", "Session identifier").action(async (options, command) => {
-    await runCommand(command, (client, globalOptions) => {
-      const runtime = resolveCoreRuntime({
-        host: globalOptions.host,
-        port: globalOptions.port,
-        strictEnvPort: true
-      });
+    await runCommand(command, (client) => {
       const payload = parseInput(DiagnosticsDoctorInputSchema, {
-        session_id: options.sessionId,
-        caller: {
-          endpoint: {
-            host: runtime.host,
-            port: runtime.port,
-            base_url: `http://${runtime.host}:${runtime.port}`,
-            host_source: runtime.hostSource,
-            port_source: runtime.portSource
-          },
-          process: {
-            component: "cli"
-          }
-        }
+        session_id: options.sessionId
       });
       return client.post("/diagnostics/doctor", payload);
     });
@@ -1783,7 +1957,7 @@ var registerDiagnosticsCommands = (program2) => {
   diagnostics.command("health-check").description("Run a lightweight health check").action(async (_options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(HealthCheckInputSchema, {});
-      return client.post("/health_check", payload);
+      return client.post("/health/check", payload);
     });
   });
 };
@@ -2004,12 +2178,30 @@ var parseJson = (value, label) => {
     throw new Error(`${label} must be valid JSON.`);
   }
 };
+var addDeprecatedAliasWarning = (envelope2, aliasName, replacementName) => {
+  if (!envelope2.ok || typeof envelope2.result !== "object" || !envelope2.result) {
+    return envelope2;
+  }
+  const warning = `${aliasName} is deprecated; use ${replacementName}.`;
+  const result = envelope2.result;
+  const existingWarnings = Array.isArray(result.warnings) ? result.warnings.filter((item) => typeof item === "string") : [];
+  return {
+    ok: true,
+    result: {
+      ...result,
+      warnings: existingWarnings.includes(warning) ? existingWarnings : [...existingWarnings, warning]
+    }
+  };
+};
 var registerDriveCommands = (program2) => {
   const drive = program2.command("drive").description("Drive commands");
-  drive.command("navigate").description("Navigate to a URL").requiredOption("--session-id <id>", "Session identifier").requiredOption("--url <url>", "URL to navigate to").option("--tab-id <id>", "Tab identifier (defaults to agent window/tab)").option("--wait <mode>", "Wait mode (none, domcontentloaded)").action(async (options, command) => {
+  drive.command("navigate").description("Navigate to a URL").option(
+    "--session-id <id>",
+    "Session identifier (auto-created when omitted)"
+  ).requiredOption("--url <url>", "URL to navigate to").option("--tab-id <id>", "Tab identifier (defaults to agent window/tab)").option("--wait <mode>", "Wait mode (none, domcontentloaded)").action(async (options, command) => {
     await runCommand(command, (client) => {
       const payload = parseInput(DriveNavigateInputSchema, {
-        session_id: options.sessionId,
+        ...options.sessionId ? { session_id: options.sessionId } : {},
         url: options.url,
         tab_id: parseNumber3(options.tabId),
         wait: options.wait
@@ -2026,13 +2218,15 @@ var registerDriveCommands = (program2) => {
       return client.post("/drive/go_back", payload);
     });
   });
-  drive.command("back").description("Go back in browser history").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier (defaults to agent window/tab)").action(async (options, command) => {
+  drive.command("back").description("Deprecated alias for go-back").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier (defaults to agent window/tab)").action(async (options, command) => {
     await runCommand(command, (client) => {
-      const payload = parseInput(DriveBackInputSchema, {
+      const payload = parseInput(DriveGoBackInputSchema, {
         session_id: options.sessionId,
         tab_id: parseNumber3(options.tabId)
       });
-      return client.post("/drive/back", payload);
+      return client.post("/drive/go_back", payload).then(
+        (envelope2) => addDeprecatedAliasWarning(envelope2, "drive.back", "drive.go_back")
+      );
     });
   });
   drive.command("go-forward").description("Go forward in browser history").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier (defaults to agent window/tab)").action(async (options, command) => {
@@ -2044,13 +2238,19 @@ var registerDriveCommands = (program2) => {
       return client.post("/drive/go_forward", payload);
     });
   });
-  drive.command("forward").description("Go forward in browser history").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier (defaults to agent window/tab)").action(async (options, command) => {
+  drive.command("forward").description("Deprecated alias for go-forward").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier (defaults to agent window/tab)").action(async (options, command) => {
     await runCommand(command, (client) => {
-      const payload = parseInput(DriveForwardInputSchema, {
+      const payload = parseInput(DriveGoForwardInputSchema, {
         session_id: options.sessionId,
         tab_id: parseNumber3(options.tabId)
       });
-      return client.post("/drive/forward", payload);
+      return client.post("/drive/go_forward", payload).then(
+        (envelope2) => addDeprecatedAliasWarning(
+          envelope2,
+          "drive.forward",
+          "drive.go_forward"
+        )
+      );
     });
   });
   drive.command("click").description("Click an element").requiredOption("--session-id <id>", "Session identifier").option("--tab-id <id>", "Tab identifier (defaults to agent window/tab)").option("--locator-ref <ref>", "Locator ref (e.g., @e1)").option("--locator-testid <id>", "Locator test id").option("--locator-css <selector>", "Locator CSS selector").option("--locator-text <text>", "Locator text").option("--locator-role <role>", "Locator role name").option("--locator-role-value <value>", "Locator role value").option("--click-count <count>", "Click count").action(async (options, command) => {
@@ -2400,6 +2600,12 @@ var toReadinessErrorEnvelope = (error, baseUrl) => ({
     code: "UNAVAILABLE",
     message: error instanceof Error ? `Core not ready at ${baseUrl}: ${error.message}` : `Core not ready at ${baseUrl}.`,
     retryable: true,
+    retry: {
+      retryable: true,
+      reason: "core_not_ready",
+      retry_after_ms: 250,
+      max_attempts: 1
+    },
     details: {
       base_url: baseUrl
     }
@@ -2477,7 +2683,8 @@ startCoreServer({ ${startOptions.join(
       const response = await fetchImpl(`${readiness.baseUrl}${requestPath}`, {
         method: "POST",
         headers: {
-          "content-type": "application/json"
+          "content-type": "application/json",
+          [HTTP_CONTRACT_VERSION_HEADER]: HTTP_CONTRACT_VERSION
         },
         body: body === void 0 ? void 0 : JSON.stringify(body),
         signal: controller.signal
@@ -2590,6 +2797,22 @@ var toInternalErrorEnvelope = (error) => ({
   }
 });
 var envelope = (schema) => successEnvelopeSchema(schema);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var addDeprecatedAliasWarning2 = (envelopeResult, deprecationAlias) => {
+  if (!deprecationAlias || !envelopeResult.ok || typeof envelopeResult.result !== "object" || !envelopeResult.result) {
+    return envelopeResult;
+  }
+  const warning = `${deprecationAlias.alias} is deprecated; use ${deprecationAlias.replacement}.`;
+  const result = envelopeResult.result;
+  const existingWarnings = Array.isArray(result.warnings) ? result.warnings.filter((item) => typeof item === "string") : [];
+  return {
+    ok: true,
+    result: {
+      ...result,
+      warnings: existingWarnings.includes(warning) ? existingWarnings : [...existingWarnings, warning]
+    }
+  };
+};
 var TOOL_DEFINITIONS = [
   {
     name: "session.create",
@@ -2665,20 +2888,28 @@ var TOOL_DEFINITIONS = [
     name: "drive.back",
     config: {
       title: "Drive Back",
-      description: "Go back in browser history.",
-      inputSchema: DriveBackInputSchema,
-      outputSchema: envelope(DriveBackOutputSchema),
-      corePath: "/drive/back"
+      description: "Deprecated alias for drive.go_back.",
+      inputSchema: DriveGoBackInputSchema,
+      outputSchema: envelope(DriveGoBackOutputSchema),
+      corePath: "/drive/go_back",
+      deprecationAlias: {
+        alias: "drive.back",
+        replacement: "drive.go_back"
+      }
     }
   },
   {
     name: "drive.forward",
     config: {
       title: "Drive Forward",
-      description: "Go forward in browser history.",
-      inputSchema: DriveForwardInputSchema,
-      outputSchema: envelope(DriveForwardOutputSchema),
-      corePath: "/drive/forward"
+      description: "Deprecated alias for drive.go_forward.",
+      inputSchema: DriveGoForwardInputSchema,
+      outputSchema: envelope(DriveGoForwardOutputSchema),
+      corePath: "/drive/go_forward",
+      deprecationAlias: {
+        alias: "drive.forward",
+        replacement: "drive.go_forward"
+      }
     }
   },
   {
@@ -2755,20 +2986,30 @@ var TOOL_DEFINITIONS = [
     name: "dialog.accept",
     config: {
       title: "Dialog Accept",
-      description: "Accept a JavaScript dialog.",
+      description: "Deprecated alias for drive.handle_dialog (action=accept).",
       inputSchema: DialogAcceptInputSchema,
       outputSchema: envelope(DialogAcceptOutputSchema),
-      corePath: "/dialog/accept"
+      corePath: "/drive/handle_dialog",
+      deprecationAlias: {
+        alias: "dialog.accept",
+        replacement: "drive.handle_dialog"
+      },
+      transformInput: (args) => isRecord(args) ? { ...args, action: "accept" } : args
     }
   },
   {
     name: "dialog.dismiss",
     config: {
       title: "Dialog Dismiss",
-      description: "Dismiss a JavaScript dialog.",
+      description: "Deprecated alias for drive.handle_dialog (action=dismiss).",
       inputSchema: DialogDismissInputSchema,
       outputSchema: envelope(DialogDismissOutputSchema),
-      corePath: "/dialog/dismiss"
+      corePath: "/drive/handle_dialog",
+      deprecationAlias: {
+        alias: "dialog.dismiss",
+        replacement: "drive.handle_dialog"
+      },
+      transformInput: (args) => isRecord(args) ? { ...args, action: "dismiss" } : args
     }
   },
   {
@@ -2948,7 +3189,7 @@ var TOOL_DEFINITIONS = [
       description: "Check server health including uptime, memory usage, active session count, and extension connection status.",
       inputSchema: HealthCheckInputSchema,
       outputSchema: envelope(HealthCheckOutputSchema),
-      corePath: "/health_check"
+      corePath: "/health/check"
     }
   },
   {
@@ -2962,13 +3203,18 @@ var TOOL_DEFINITIONS = [
     }
   }
 ];
-var createToolHandler = (clientProvider, corePath) => {
+var createToolHandler = (clientProvider, corePath, deprecationAlias, transformInput) => {
   return (async (args, _extra) => {
     void _extra;
     try {
       const client = typeof clientProvider === "function" ? await clientProvider() : clientProvider;
-      const envelopeResult = await client.post(corePath, args);
-      return toToolResult(envelopeResult);
+      const envelopeResult = await client.post(
+        corePath,
+        transformInput ? transformInput(args) : args
+      );
+      return toToolResult(
+        addDeprecatedAliasWarning2(envelopeResult, deprecationAlias)
+      );
     } catch (error) {
       const parsed = ErrorEnvelopeSchema.safeParse(error);
       if (parsed.success) {
@@ -2988,7 +3234,12 @@ var registerBrowserBridgeTools = (server, clientProvider) => {
         inputSchema: tool.config.inputSchema,
         outputSchema: tool.config.outputSchema
       },
-      createToolHandler(clientProvider, tool.config.corePath)
+      createToolHandler(
+        clientProvider,
+        tool.config.corePath,
+        tool.config.deprecationAlias,
+        tool.config.transformInput
+      )
     );
   }
 };