@btraut/browser-bridge 0.14.0 → 0.15.0

package/dist/api.js

@@ -687,9 +687,10 @@ var createCoreReadinessController = (options = {}) => {
       return;
     }
     if (!ensurePromise) {
-      ensurePromise = ensureCoreRunning().catch((error) => {
+      ensurePromise = (async () => {
+        await ensureCoreRunning();
+      })().finally(() => {
         ensurePromise = null;
-        throw error;
       });
     }
     await ensurePromise;
@@ -1096,6 +1097,63 @@ var SessionCloseInputSchema = SessionIdSchema;
 var SessionCloseOutputSchema = import_zod3.z.object({
   ok: import_zod3.z.boolean()
 });
+var PermissionsModeSchema = import_zod3.z.enum(["granular", "bypass"]);
+var PermissionsRequestSourceSchema = import_zod3.z.enum(["cli", "mcp", "api"]);
+var PermissionsPendingRequestKindSchema = import_zod3.z.enum([
+  "allow_site",
+  "revoke_site",
+  "set_mode"
+]);
+var PermissionsPendingRequestStatusSchema = import_zod3.z.enum([
+  "pending",
+  "approved",
+  "denied",
+  "timed_out"
+]);
+var PermissionsSiteEntrySchema = import_zod3.z.object({
+  site: import_zod3.z.string().min(1),
+  created_at: import_zod3.z.string().datetime(),
+  last_used_at: import_zod3.z.string().datetime()
+});
+var PermissionsListInputSchema = import_zod3.z.object({}).strict().default({});
+var PermissionsListOutputSchema = import_zod3.z.object({
+  sites: import_zod3.z.array(PermissionsSiteEntrySchema)
+});
+var PermissionsGetModeInputSchema = import_zod3.z.object({}).strict().default({});
+var PermissionsGetModeOutputSchema = import_zod3.z.object({
+  mode: PermissionsModeSchema
+});
+var PermissionsPendingRequestSchema = import_zod3.z.object({
+  request_id: import_zod3.z.string().min(1),
+  kind: PermissionsPendingRequestKindSchema,
+  status: PermissionsPendingRequestStatusSchema,
+  requested_at: import_zod3.z.string().datetime(),
+  site: import_zod3.z.string().min(1).optional(),
+  mode: PermissionsModeSchema.optional(),
+  source: PermissionsRequestSourceSchema.optional(),
+  warning: import_zod3.z.string().optional(),
+  message: import_zod3.z.string().optional()
+});
+var PermissionsListPendingRequestsInputSchema = import_zod3.z.object({}).strict().default({});
+var PermissionsListPendingRequestsOutputSchema = import_zod3.z.object({
+  requests: import_zod3.z.array(PermissionsPendingRequestSchema)
+});
+var PermissionsRequestAllowSiteInputSchema = import_zod3.z.object({
+  site: import_zod3.z.string().min(1),
+  timeout_ms: import_zod3.z.number().int().positive().max(3e5).optional(),
+  source: PermissionsRequestSourceSchema.optional()
+});
+var PermissionsRequestRevokeSiteInputSchema = import_zod3.z.object({
+  site: import_zod3.z.string().min(1),
+  timeout_ms: import_zod3.z.number().int().positive().max(3e5).optional(),
+  source: PermissionsRequestSourceSchema.optional()
+});
+var PermissionsRequestSetModeInputSchema = import_zod3.z.object({
+  mode: PermissionsModeSchema,
+  timeout_ms: import_zod3.z.number().int().positive().max(3e5).optional(),
+  source: PermissionsRequestSourceSchema.optional()
+});
+var PermissionsRequestOutputSchema = PermissionsPendingRequestSchema;
 var DriveWaitConditionSchema = import_zod3.z.object({
   kind: import_zod3.z.enum(["locator_visible", "text_present", "url_matches"]),
   value: import_zod3.z.string().min(1)
@@ -1282,6 +1340,12 @@ var FormFieldInfoSchema = import_zod3.z.object({
   name: import_zod3.z.string(),
   type: import_zod3.z.string(),
   value: import_zod3.z.string(),
+  selector: import_zod3.z.string().optional(),
+  label: import_zod3.z.string().optional(),
+  placeholder: import_zod3.z.string().optional(),
+  checked: import_zod3.z.boolean().optional(),
+  disabled: import_zod3.z.boolean().optional(),
+  visible: import_zod3.z.boolean().optional(),
   options: import_zod3.z.array(import_zod3.z.string()).optional()
 });
 var FormInfoSchema = import_zod3.z.object({
@@ -1294,7 +1358,31 @@ var StorageEntrySchema = import_zod3.z.object({
   key: import_zod3.z.string(),
   value: import_zod3.z.string()
 });
+var FocusedElementSchema = import_zod3.z.object({
+  selector: import_zod3.z.string().optional(),
+  name: import_zod3.z.string().optional(),
+  label: import_zod3.z.string().optional(),
+  role: import_zod3.z.string().optional(),
+  type: import_zod3.z.string().optional(),
+  text: import_zod3.z.string().optional()
+});
+var PageActionSchema = import_zod3.z.object({
+  selector: import_zod3.z.string(),
+  role: import_zod3.z.string(),
+  name: import_zod3.z.string()
+});
+var StorageSummarySchema = import_zod3.z.object({
+  localStorageCount: import_zod3.z.number().int().nonnegative(),
+  sessionStorageCount: import_zod3.z.number().int().nonnegative(),
+  cookieCount: import_zod3.z.number().int().nonnegative()
+});
 var PageStateSchema = import_zod3.z.object({
+  url: import_zod3.z.string().optional(),
+  title: import_zod3.z.string().optional(),
+  readyState: import_zod3.z.string().optional(),
+  focused: FocusedElementSchema.optional(),
+  primaryActions: import_zod3.z.array(PageActionSchema).optional(),
+  storageSummary: StorageSummarySchema.optional(),
   forms: import_zod3.z.array(FormInfoSchema),
   localStorage: import_zod3.z.array(StorageEntrySchema),
   sessionStorage: import_zod3.z.array(StorageEntrySchema),
@@ -1357,6 +1445,7 @@ var InspectFindOutputSchema = import_zod3.z.object({
   warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
 var InspectPageStateInputSchema = SessionIdSchema.extend({
+  include_values: import_zod3.z.boolean().default(false),
   target: TargetHintSchema.optional()
 });
 var InspectPageStateOutputSchema = PageStateSchema;
@@ -1367,6 +1456,7 @@ var InspectExtractContentFormatSchema = import_zod3.z.enum([
 ]);
 var InspectExtractContentInputSchema = SessionIdSchema.extend({
   format: InspectExtractContentFormatSchema.default("markdown"),
+  consistency: InspectConsistencySchema.default("quiesce"),
   include_metadata: import_zod3.z.boolean().default(true),
   target: TargetHintSchema.optional()
 });
@@ -1379,6 +1469,7 @@ var InspectExtractContentOutputSchema = import_zod3.z.object({
   warnings: import_zod3.z.array(import_zod3.z.string()).optional()
 });
 var InspectConsoleListInputSchema = SessionIdSchema.extend({
+  since: import_zod3.z.string().optional(),
   target: TargetHintSchema.optional()
 });
 var ConsoleSourceLocationSchema = import_zod3.z.object({
@@ -1983,6 +2074,7 @@ var ExtensionBridge = class {
   constructor(options = {}) {
     this.socket = null;
     this.pending = /* @__PURE__ */ new Map();
+    this.readyWaiters = /* @__PURE__ */ new Set();
     this.connected = false;
     this.capabilityNegotiated = false;
     this.capabilities = {};
@@ -2031,6 +2123,36 @@ var ExtensionBridge = class {
       tabs: this.tabs
     };
   }
+  async waitForReady(timeoutMs = 1500) {
+    if (this.isReadyForRequests()) {
+      return true;
+    }
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      return this.isReadyForRequests();
+    }
+    return await new Promise((resolve3) => {
+      let settled = false;
+      const finish = (value) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timeout);
+        this.readyWaiters.delete(waiter);
+        resolve3(value);
+      };
+      const waiter = () => {
+        if (this.isReadyForRequests()) {
+          finish(true);
+        }
+      };
+      const timeout = setTimeout(() => {
+        finish(this.isReadyForRequests());
+      }, timeoutMs);
+      this.readyWaiters.add(waiter);
+      waiter();
+    });
+  }
   async request(action, params, timeoutMs = 3e4) {
     const response = await this.requestInternal(action, params, timeoutMs);
     return response;
@@ -2102,6 +2224,7 @@ var ExtensionBridge = class {
       status: "request",
       params
     };
+    const envelope2 = request;
     const response = await new Promise((resolve3, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
@@ -2119,7 +2242,7 @@ var ExtensionBridge = class {
         reject,
         timeout
       });
-      this.socket?.send(JSON.stringify(request));
+      this.socket?.send(JSON.stringify(envelope2));
     });
     return response;
   }
@@ -2310,6 +2433,7 @@ var ExtensionBridge = class {
             expected: "drive.hello.capabilities"
           };
         }
+        this.flushReadyWaiters();
       }
     }
     if (typeof message.action === "string" && message.action.startsWith("debugger.")) {
@@ -2325,6 +2449,23 @@ var ExtensionBridge = class {
       }
     }
   }
+  isReadyForRequests() {
+    return this.connected && this.capabilityNegotiated;
+  }
+  flushReadyWaiters() {
+    if (!this.isReadyForRequests() || this.readyWaiters.size === 0) {
+      return;
+    }
+    const waiters = Array.from(this.readyWaiters);
+    this.readyWaiters.clear();
+    for (const waiter of waiters) {
+      try {
+        waiter();
+      } catch (error) {
+        console.debug("Extension ready waiter failed.", error);
+      }
+    }
+  }
   applyDriveConnected() {
     if (!this.registry) {
       return;
@@ -2379,7 +2520,8 @@ var toDriveError = (error) => ({
 // packages/core/src/drive.ts
 var LOOPBACK_NAVIGATION_PREFLIGHT_TIMEOUT_MS = 1200;
 var POST_CLICK_SETTLE_MS = 75;
-var TRANSIENT_LOCATOR_RETRY_DELAY_MS = 150;
+var TRANSIENT_LOCATOR_RETRY_DELAYS_MS = [150, 300, 600];
+var EXTENSION_READY_WAIT_MS = 1500;
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
 var ACTIONS_WITH_OPTIONAL_TAB_ID = /* @__PURE__ */ new Set([
   "drive.navigate",
@@ -2497,6 +2639,16 @@ var DriveController = class {
   async sleep(ms) {
     await new Promise((resolve3) => setTimeout(resolve3, ms));
   }
+  async waitForBridgeReady() {
+    if (this.bridge.isConnected()) {
+      return true;
+    }
+    const waitForReady = this.bridge.waitForReady;
+    if (typeof waitForReady === "function") {
+      return await waitForReady.call(this.bridge, EXTENSION_READY_WAIT_MS);
+    }
+    return this.bridge.isConnected();
+  }
   isTransientLocatorError(action, error) {
     if (action !== "drive.click") {
       return false;
@@ -2538,7 +2690,7 @@ var DriveController = class {
           error: errorInfo
         };
       }
-      if (!this.bridge.isConnected()) {
+      if (!await this.waitForBridgeReady()) {
         const errorInfo = {
           code: "EXTENSION_DISCONNECTED",
           message: "Extension is not connected. Open Chrome with the Browser Bridge extension enabled, then retry.",
@@ -2604,9 +2756,10 @@ var DriveController = class {
               max_attempts: 1
             }
           };
-          if (attempt === 0 && this.isTransientLocatorError(action, errorInfo)) {
+          if (attempt < TRANSIENT_LOCATOR_RETRY_DELAYS_MS.length && this.isTransientLocatorError(action, errorInfo)) {
+            const delayMs = TRANSIENT_LOCATOR_RETRY_DELAYS_MS[attempt] ?? 0;
             attempt += 1;
-            await this.sleep(TRANSIENT_LOCATOR_RETRY_DELAY_MS);
+            await this.sleep(delayMs);
             continue;
           }
           if (shouldRetryDriveOp({
@@ -2884,6 +3037,10 @@ var filterAxSnapshot = (snapshot, predicate) => {
   }
   return replaceAxNodes(snapshot, filtered);
 };
+var filterAxSnapshotByRefs = (snapshot, allowedRefs) => filterAxSnapshot(snapshot, (node) => {
+  const ref = node.ref;
+  return typeof ref === "string" && allowedRefs.has(ref);
+});
 var collectKeptDescendants = (nodeId, nodeById, keepIds, visited = /* @__PURE__ */ new Set()) => {
   if (visited.has(nodeId)) {
     return [];
@@ -3514,7 +3671,8 @@ var captureHtml = async (tabId, options) => {
   const result = await options.debuggerCommand(tabId, "Runtime.evaluate", {
     expression,
     returnByValue: true,
-    awaitPromise: true
+    awaitPromise: true,
+    ...typeof options.executionContextId === "number" ? { contextId: options.executionContextId } : {}
   });
   if (result && typeof result === "object" && "exceptionDetails" in result) {
     return options.onEvaluationFailed();
@@ -4033,111 +4191,209 @@ var selectInspectTab = (options) => {
 };
 
 // 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");
+var buildPageStateScript = (options) => {
+  const includeValues = options?.includeValues === true;
+  return [
+    "(() => {",
+    `  const includeValues = ${includeValues ? "true" : "false"};`,
+    "  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 redact = (value) => (includeValues ? truncate(value, 500) : "[redacted]");',
+    '  const textFor = (element) => truncate((element?.textContent || "").replace(/\\s+/g, " ").trim(), 120);',
+    "  const isVisible = (element) => {",
+    '    if (!element || typeof element.getClientRects !== "function") {',
+    "      return false;",
+    "    }",
+    "    const style = window.getComputedStyle(element);",
+    '    if (style.display === "none" || style.visibility === "hidden") {',
+    "      return false;",
+    "    }",
+    '    if (element.hidden || element.getAttribute("aria-hidden") === "true") {',
+    "      return false;",
+    "    }",
+    "    return element.getClientRects().length > 0;",
+    "  };",
+    "  const selectorFor = (element) => {",
+    "    if (!element || element.nodeType !== 1) {",
+    '      return "";',
+    "    }",
+    "    if (element.id) {",
+    "      return `#${escape(element.id)}`;",
+    "    }",
+    '    const testId = element.getAttribute("data-testid");',
+    "    if (testId) {",
+    '      return `[data-testid="${escape(testId)}"]`;',
+    "    }",
+    '    const name = element.getAttribute("name");',
+    "    if (name) {",
+    '      return `${element.tagName.toLowerCase()}[name="${escape(name)}"]`;',
+    "    }",
+    '    const ariaLabel = element.getAttribute("aria-label");',
+    "    if (ariaLabel) {",
+    '      return `${element.tagName.toLowerCase()}[aria-label="${escape(ariaLabel)}"]`;',
+    "    }",
+    "    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 labelFor = (element) => {",
+    "    if (!element) {",
+    "      return undefined;",
+    "    }",
+    '    const ariaLabel = element.getAttribute("aria-label");',
+    "    if (ariaLabel) {",
+    "      return truncate(ariaLabel, 120);",
+    "    }",
+    "    if (element.id) {",
+    '      const explicitLabel = document.querySelector(`label[for="${escape(element.id)}"]`);',
+    "      if (explicitLabel) {",
+    "        return textFor(explicitLabel);",
+    "      }",
+    "    }",
+    '    const parentLabel = element.closest("label");',
+    "    if (parentLabel) {",
+    "      return textFor(parentLabel);",
+    "    }",
+    "    return undefined;",
+    "  };",
+    "  const readStorage = (storage, limit) => {",
+    "    try {",
+    "      const keys = Object.keys(storage);",
+    "      return {",
+    "        count: keys.length,",
+    "        entries: keys.slice(0, limit).map((key) => ({",
+    "          key,",
+    "          value: redact(storage.getItem(key)),",
+    "        })),",
+    "      };",
+    "    } catch {",
+    "      return { count: 0, entries: [] };",
+    "    }",
+    "  };",
+    '  const forms = Array.from(document.querySelectorAll("form"))',
+    "    .filter((form) => isVisible(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 = redact(select.value ?? "");',
+    "            options = Array.from(select.options).map((option) => truncate(option.text, 120));",
+    '          } else if (tag === "input" && element.type === "password") {',
+    '            value = "[redacted]";',
+    '          } else if (tag === "input" || tag === "textarea") {',
+    '            value = redact(element.value ?? "");',
+    "          } else if (element.isContentEditable) {",
+    '            value = redact(element.textContent ?? "");',
+    '          } else if ("value" in element) {',
+    '            value = redact(element.value ?? "");',
+    "          }",
+    "          return {",
+    "            name,",
+    "            type,",
+    "            value,",
+    "            selector: selectorFor(element),",
+    "            label: labelFor(element),",
+    '            placeholder: truncate(element.getAttribute?.("placeholder") ?? "", 120) || undefined,',
+    '            checked: typeof element.checked === "boolean" ? element.checked : undefined,',
+    "            disabled: !!element.disabled,",
+    "            visible: isVisible(element),",
+    "            ...(options ? { options } : {}),",
+    "          };",
+    "        });",
+    "      return {",
+    "        selector: selectorFor(form),",
+    '        action: form.getAttribute("action") || undefined,',
+    '        method: form.getAttribute("method") || undefined,',
+    "        fields,",
+    "      };",
+    "    });",
+    "  const localStorageData = readStorage(window.localStorage, 25);",
+    "  const sessionStorageData = readStorage(window.sessionStorage, 25);",
+    '  const cookies = (document.cookie ? document.cookie.split(";") : [])',
+    "    .map((entry) => entry.trim())",
+    "    .filter((entry) => entry.length > 0)",
+    "    .slice(0, 25)",
+    "    .map((entry) => {",
+    '      const [key, ...rest] = entry.split("=");',
+    "      return {",
+    "        key,",
+    '        value: includeValues ? truncate(rest.join("="), 500) : "[redacted]",',
+    "      };",
+    "    });",
+    "  const focused = document.activeElement && document.activeElement !== document.body",
+    "    ? {",
+    "        selector: selectorFor(document.activeElement),",
+    '        name: document.activeElement.getAttribute?.("name") || document.activeElement.id || undefined,',
+    "        label: labelFor(document.activeElement),",
+    '        role: document.activeElement.getAttribute?.("role") || document.activeElement.tagName?.toLowerCase(),',
+    '        type: document.activeElement.getAttribute?.("type") || undefined,',
+    "        text: textFor(document.activeElement) || undefined,",
+    "      }",
+    "    : undefined;",
+    '  const primaryActions = Array.from(document.querySelectorAll("button, a[href], input[type=button], input[type=submit]"))',
+    "    .filter((element) => isVisible(element))",
+    "    .map((element) => ({",
+    "      selector: selectorFor(element),",
+    '      role: element.getAttribute("role") || element.tagName.toLowerCase(),',
+    '      name: truncate(element.getAttribute("aria-label") || element.innerText || element.value || "", 120),',
+    "    }))",
+    "    .filter((entry) => entry.name.length > 0)",
+    "    .slice(0, 12);",
+    "  return {",
+    "    url: location.href,",
+    "    title: document.title || undefined,",
+    "    readyState: document.readyState || undefined,",
+    "    focused,",
+    "    primaryActions,",
+    "    storageSummary: {",
+    "      localStorageCount: localStorageData.count,",
+    "      sessionStorageCount: sessionStorageData.count,",
+    "      cookieCount: cookies.length,",
+    "    },",
+    "    forms,",
+    "    localStorage: localStorageData.entries,",
+    "    sessionStorage: sessionStorageData.entries,",
+    "    cookies,",
+    "  };",
+    "})()"
+  ].join("\n");
+};
 
 // packages/core/src/inspect/service.ts
 var DEFAULT_MAX_SNAPSHOTS_PER_SESSION = 20;
 var DEFAULT_MAX_SNAPSHOT_HISTORY = 100;
 var InspectService = class {
   constructor(options) {
+    this.consoleSinceBySessionTab = /* @__PURE__ */ new Map();
     this.registry = options.registry;
     this.debugger = options.debuggerBridge;
     this.extensionBridge = options.extensionBridge;
@@ -4198,11 +4454,15 @@ var InspectService = class {
     this.requireSession(input.sessionId);
     const selection = await this.resolveTab(input.sessionId, input.targetHint);
     const debuggerCommand = this.debuggerCommand.bind(this);
+    const executionContextId = await this.resolveMainFrameExecutionContextId(
+      selection.tabId
+    );
     const work = async () => {
       if (input.format === "html") {
         const html = await captureHtml(selection.tabId, {
           selector: input.selector,
           debuggerCommand,
+          executionContextId,
           onEvaluationFailed: () => {
             const error = new InspectError(
               "EVALUATION_FAILED",
@@ -4296,18 +4556,36 @@ var InspectService = class {
           refMap,
           debuggerCommand
         );
+        let actionableRefs = refResult.appliedRefs;
+        let actionableBindings = refResult.appliedBindings;
+        const actionabilityWarnings = [];
+        if (input.interactive && refResult.appliedBindings.length > 0) {
+          const actionableResult = await this.collectActionableSnapshotRefs(
+            selection.tabId,
+            refResult.appliedBindings
+          );
+          actionabilityWarnings.push(...actionableResult.warnings);
+          if (actionableResult.actionableRefs) {
+            actionableRefs = actionableResult.actionableRefs;
+            actionableBindings = refResult.appliedBindings.filter(
+              (binding) => actionableRefs.has(binding.ref)
+            );
+            snapshot = filterAxSnapshotByRefs(snapshot, actionableRefs);
+          }
+        }
         const persistResult = refMap.size === 0 ? { warnings: [] } : await persistSnapshotRefRegistry(
           selection.tabId,
-          refResult.appliedBindings,
+          actionableBindings,
           debuggerCommand
         );
-        pruneUnappliedRefsFromSnapshot(snapshot, refResult.appliedRefs);
+        pruneUnappliedRefsFromSnapshot(snapshot, actionableRefs);
         const warnings = [
           ...selection.warnings ?? [],
           ...selectorWarnings,
           ...truncationWarnings,
           ...clearResult.warnings,
           ...refResult.warnings,
+          ...actionabilityWarnings,
           ...persistResult.warnings
         ];
         return {
@@ -4329,6 +4607,7 @@ var InspectService = class {
           const html = await captureHtml(selection.tabId, {
             selector: input.selector,
             debuggerCommand,
+            executionContextId,
             onEvaluationFailed: () => {
               const error2 = new InspectError(
                 "EVALUATION_FAILED",
@@ -4433,11 +4712,27 @@ var InspectService = class {
     };
   }
   async consoleList(input) {
-    this.requireSession(input.sessionId);
+    const session = this.requireSession(input.sessionId);
+    const tabCount = this.extensionBridge?.getStatus().tabs.length ?? 0;
+    if (!input.targetHint && typeof session.selectedTabId !== "number" && tabCount > 1) {
+      const error = new InspectError(
+        "TAB_NOT_FOUND",
+        "Console inspection requires an explicit target or a session-selected tab.",
+        { retryable: false }
+      );
+      this.recordError(error);
+      throw error;
+    }
     const selection = await this.resolveTab(input.sessionId, input.targetHint);
     await this.enableConsole(selection.tabId);
+    const since = this.resolveConsoleSince({
+      session,
+      tabId: selection.tabId,
+      requestedSince: input.since,
+      tabLastActiveAt: selection.tab.last_active_at
+    });
     const events = this.ensureDebugger().getConsoleEvents(selection.tabId);
-    const entries = events.map((event) => toConsoleEntry(event)).filter((entry) => entry !== null);
+    const entries = events.filter((event) => this.isEventOnOrAfter(event.timestamp, since)).map((event) => toConsoleEntry(event)).filter((entry) => entry !== null);
     const result = {
       entries,
       warnings: selection.warnings
@@ -4476,16 +4771,7 @@ var InspectService = class {
     this.requireSession(input.sessionId);
     const selection = await this.resolveTab(input.sessionId, 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
-      }
-    );
+    const result = await this.evaluateInMainFrame(selection.tabId, expression);
     if (result && typeof result === "object" && "exceptionDetails" in result) {
       const output2 = {
         exception: result.exceptionDetails,
@@ -4504,54 +4790,58 @@ var InspectService = class {
   async extractContent(input) {
     this.requireSession(input.sessionId);
     const selection = await this.resolveTab(input.sessionId, input.targetHint);
+    const consistency = input.consistency ?? "quiesce";
     const debuggerCommand = this.debuggerCommand.bind(this);
-    const html = await captureHtml(selection.tabId, {
-      debuggerCommand,
-      onEvaluationFailed: () => {
-        const error = new InspectError(
-          "EVALUATION_FAILED",
-          "Failed to evaluate HTML snapshot.",
-          { retryable: false }
-        );
-        this.recordError(error);
-        throw error;
-      }
-    });
+    const executionContextId = await this.resolveMainFrameExecutionContextId(
+      selection.tabId
+    );
     const url = selection.tab.url ?? "about:blank";
-    try {
-      const { article, semanticMainCandidate } = parseExtractContentSource({
-        html,
-        url
-      });
-      const output = renderExtractContent({
-        format: input.format,
-        article,
-        semanticMainCandidate,
-        includeMetadata: input.includeMetadata,
-        warnings: selection.warnings
+    const work = async () => {
+      if (consistency === "quiesce") {
+        await this.waitForDomSettled(selection.tabId, executionContextId);
+      }
+      const html = await captureHtml(selection.tabId, {
+        debuggerCommand,
+        executionContextId,
+        onEvaluationFailed: () => {
+          const error = new InspectError(
+            "EVALUATION_FAILED",
+            "Failed to evaluate HTML snapshot.",
+            { retryable: false }
+          );
+          this.recordError(error);
+          throw error;
+        }
       });
-      this.markInspectConnected(input.sessionId);
-      return output;
-    } catch (error) {
-      if (error instanceof InspectError) {
-        this.recordError(error);
+      try {
+        const { article, semanticMainCandidate } = parseExtractContentSource({
+          html,
+          url
+        });
+        return renderExtractContent({
+          format: input.format,
+          article,
+          semanticMainCandidate,
+          includeMetadata: input.includeMetadata,
+          warnings: selection.warnings
+        });
+      } catch (error) {
+        if (error instanceof InspectError) {
+          this.recordError(error);
+        }
+        throw error;
       }
-      throw error;
-    }
+    };
+    const output = consistency === "quiesce" ? await driveMutex.runExclusive(work) : await work();
+    this.markInspectConnected(input.sessionId);
+    return output;
   }
   async pageState(input) {
     this.requireSession(input.sessionId);
     const selection = await this.resolveTab(input.sessionId, input.targetHint);
-    await this.debuggerCommand(selection.tabId, "Runtime.enable", {});
-    const expression = PAGE_STATE_SCRIPT;
-    const result = await this.debuggerCommand(
+    const result = await this.evaluateInMainFrame(
       selection.tabId,
-      "Runtime.evaluate",
-      {
-        expression,
-        returnByValue: true,
-        awaitPromise: true
-      }
+      buildPageStateScript({ includeValues: input.includeValues })
     );
     if (result && typeof result === "object" && "exceptionDetails" in result) {
       const error = new InspectError(
@@ -4563,16 +4853,22 @@ var InspectService = class {
       throw error;
     }
     const value = result?.result?.value;
-    const raw = value && typeof value === "object" ? value : {};
+    const parsed = PageStateSchema.safeParse(value);
+    if (!parsed.success) {
+      const error = new InspectError(
+        "EVALUATION_FAILED",
+        "Captured page state did not match the expected schema.",
+        { retryable: false }
+      );
+      this.recordError(error);
+      throw error;
+    }
     const warnings = [
-      ...Array.isArray(raw.warnings) ? raw.warnings : [],
+      ...parsed.data.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 : [],
+      ...parsed.data,
       ...warnings.length > 0 ? { warnings } : {}
     };
     this.markInspectConnected(input.sessionId);
@@ -4796,6 +5092,186 @@ var InspectService = class {
   async enableAccessibility(tabId) {
     await this.debuggerCommand(tabId, "Accessibility.enable", {});
   }
+  async collectActionableSnapshotRefs(tabId, bindings) {
+    try {
+      const result = await this.debuggerCommand(tabId, "Runtime.evaluate", {
+        expression: `(() => {
+          const refs = new Set(${JSON.stringify(
+          bindings.map((binding) => binding.ref)
+        )});
+          const isVisible = (element) => {
+            if (!(element instanceof HTMLElement)) {
+              return false;
+            }
+            const style = window.getComputedStyle(element);
+            if (style.visibility === 'hidden' || style.display === 'none') {
+              return false;
+            }
+            const rect = element.getBoundingClientRect();
+            if (rect.width === 0 && rect.height === 0) {
+              return false;
+            }
+            if (
+              element.offsetWidth === 0 &&
+              element.offsetHeight === 0 &&
+              element.getClientRects().length === 0
+            ) {
+              return false;
+            }
+            let current = element;
+            while (current) {
+              const currentStyle = window.getComputedStyle(current);
+              if (currentStyle.display === 'none') {
+                return false;
+              }
+              if (
+                currentStyle.visibility === 'hidden' ||
+                currentStyle.visibility === 'collapse'
+              ) {
+                return false;
+              }
+              const opacity = Number.parseFloat(currentStyle.opacity ?? '1');
+              if (Number.isFinite(opacity) && opacity <= 0) {
+                return false;
+              }
+              if (currentStyle.pointerEvents === 'none') {
+                return false;
+              }
+              current = current.parentElement;
+            }
+            return true;
+          };
+
+          return Array.from(document.querySelectorAll('[data-bv-ref]'))
+            .filter((element) => {
+              const ref = element.getAttribute('data-bv-ref');
+              return typeof ref === 'string' && refs.has(ref) && isVisible(element);
+            })
+            .map((element) => element.getAttribute('data-bv-ref'));
+        })() /* browser-bridge:collect-actionable-snapshot-refs */`,
+        returnByValue: true,
+        awaitPromise: true
+      });
+      const rawRefs = result.value;
+      if (!Array.isArray(rawRefs)) {
+        return {
+          warnings: [
+            "Interactive AX snapshot could not verify live actionability."
+          ]
+        };
+      }
+      const refs = rawRefs.filter(
+        (ref) => typeof ref === "string"
+      );
+      return {
+        actionableRefs: new Set(refs),
+        warnings: []
+      };
+    } catch {
+      return {
+        warnings: ["Interactive AX snapshot could not prune hidden controls."]
+      };
+    }
+  }
+  async waitForDomSettled(tabId, executionContextId) {
+    const result = await this.debuggerCommand(tabId, "Runtime.evaluate", {
+      expression: `(() => {
+        const quietMs = 100;
+        const timeoutMs = 2000;
+        return new Promise((resolve) => {
+          const doc = document;
+          const root = doc.documentElement || doc.body || doc;
+          let finished = false;
+          let quietTimer;
+          let timeoutTimer;
+          let raf1 = 0;
+          let raf2 = 0;
+          const finish = () => {
+            if (finished) {
+              return;
+            }
+            finished = true;
+            if (observer) {
+              observer.disconnect();
+            }
+            clearTimeout(quietTimer);
+            clearTimeout(timeoutTimer);
+            if (raf1) cancelAnimationFrame(raf1);
+            if (raf2) cancelAnimationFrame(raf2);
+            resolve(true);
+          };
+          const scheduleQuiet = () => {
+            clearTimeout(quietTimer);
+            quietTimer = setTimeout(() => {
+              raf1 = requestAnimationFrame(() => {
+                raf2 = requestAnimationFrame(finish);
+              });
+            }, quietMs);
+          };
+          const observer =
+            typeof MutationObserver === 'function'
+              ? new MutationObserver(() => {
+                  scheduleQuiet();
+                })
+              : null;
+          if (observer && root) {
+            observer.observe(root, {
+              subtree: true,
+              childList: true,
+              attributes: true,
+              characterData: true,
+            });
+          }
+          scheduleQuiet();
+          timeoutTimer = setTimeout(finish, timeoutMs);
+        });
+      })()`,
+      returnByValue: true,
+      awaitPromise: true,
+      ...typeof executionContextId === "number" ? { contextId: executionContextId } : {}
+    });
+    if (result && typeof result === "object" && "exceptionDetails" in result) {
+      const error = new InspectError(
+        "EVALUATION_FAILED",
+        "Failed while waiting for the page to settle.",
+        { retryable: false }
+      );
+      this.recordError(error);
+      throw error;
+    }
+  }
+  async evaluateInMainFrame(tabId, expression) {
+    await this.debuggerCommand(tabId, "Runtime.enable", {});
+    const executionContextId = await this.resolveMainFrameExecutionContextId(tabId);
+    return await this.debuggerCommand(tabId, "Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+      awaitPromise: true,
+      ...typeof executionContextId === "number" ? { contextId: executionContextId } : {}
+    });
+  }
+  async resolveMainFrameExecutionContextId(tabId) {
+    const debuggerBridge = this.ensureDebugger();
+    const runOptional = async (method, params) => {
+      const result = await debuggerBridge.command(tabId, method, params);
+      if (!result.ok) {
+        return void 0;
+      }
+      return result.result;
+    };
+    await runOptional("Page.enable", {});
+    const frameTree = await runOptional("Page.getFrameTree", {});
+    const frameId = frameTree?.frameTree?.frame?.id;
+    if (typeof frameId !== "string" || frameId.length === 0) {
+      return void 0;
+    }
+    const isolatedWorld = await runOptional("Page.createIsolatedWorld", {
+      frameId,
+      worldName: "browser_bridge_inspect"
+    });
+    const contextId = isolatedWorld?.executionContextId;
+    return typeof contextId === "number" ? contextId : void 0;
+  }
   async debuggerCommand(tabId, method, params, timeoutMs) {
     const debuggerBridge = this.ensureDebugger();
     const result = await debuggerBridge.command(
@@ -4874,6 +5350,32 @@ var InspectService = class {
       throw wrapped;
     }
   }
+  resolveConsoleSince(options) {
+    if (typeof options.requestedSince === "string") {
+      return options.requestedSince;
+    }
+    const key = `${options.session.id}:${options.tabId}`;
+    const existing = this.consoleSinceBySessionTab.get(key);
+    if (existing) {
+      return existing;
+    }
+    const candidates = [options.session.createdAt.toISOString()];
+    if (typeof options.tabLastActiveAt === "string") {
+      candidates.push(options.tabLastActiveAt);
+    }
+    const baseline = candidates.map((value) => ({ value, time: Date.parse(value) })).filter((entry) => Number.isFinite(entry.time)).sort((a, b) => b.time - a.time)[0]?.value;
+    const resolved = baseline ?? options.session.createdAt.toISOString();
+    this.consoleSinceBySessionTab.set(key, resolved);
+    return resolved;
+  }
+  isEventOnOrAfter(timestamp, since) {
+    const eventTime = Date.parse(timestamp);
+    const sinceTime = Date.parse(since);
+    if (!Number.isFinite(eventTime) || !Number.isFinite(sinceTime)) {
+      return true;
+    }
+    return eventTime >= sinceTime;
+  }
 };
 var createInspectService = (options) => new InspectService(options);
 
@@ -5299,6 +5801,7 @@ var registerDiagnosticsRoutes = (router, options = {}) => {
     const extensionStatus = options.extensionBridge?.getStatus();
     sendResult(res, {
       started_at: PROCESS_STARTED_AT,
+      pid: process.pid,
       uptime_ms: Math.floor(process.uptime() * 1e3),
       memory: process.memoryUsage(),
       sessions: { active: sessionsActive },
@@ -5948,6 +6451,7 @@ var registerInspectRoutes = (router, options) => {
       return await inspect.extractContent({
         sessionId: body.session_id,
         format: body.format,
+        consistency: body.consistency,
         includeMetadata: body.include_metadata,
         targetHint: resolveInspectTargetHint({
           sessionId: body.session_id,
@@ -5963,6 +6467,7 @@ var registerInspectRoutes = (router, options) => {
     makeHandler2(InspectPageStateInputSchema, async (body) => {
       return await inspect.pageState({
         sessionId: body.session_id,
+        includeValues: body.include_values,
         targetHint: resolveInspectTargetHint({
           sessionId: body.session_id,
           target: body.target,
@@ -5977,6 +6482,7 @@ var registerInspectRoutes = (router, options) => {
     makeHandler2(InspectConsoleListInputSchema, async (body) => {
       return await inspect.consoleList({
         sessionId: body.session_id,
+        since: body.since,
         targetHint: resolveInspectTargetHint({
           sessionId: body.session_id,
           target: body.target,
@@ -6031,6 +6537,157 @@ var registerInspectRoutes = (router, options) => {
   );
 };
 
+// packages/core/src/routes/permissions.ts
+var EXTENSION_READY_WAIT_MS2 = 1500;
+var parseBody3 = (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 sendBridgeUnavailable = (res) => {
+  sendError(res, errorStatus("EXTENSION_DISCONNECTED"), {
+    code: "EXTENSION_DISCONNECTED",
+    message: "Extension bridge is unavailable.",
+    retryable: true
+  });
+};
+var waitForExtensionReady = async (extensionBridge) => {
+  if (extensionBridge.isConnected()) {
+    return true;
+  }
+  const waitForReady = extensionBridge.waitForReady;
+  if (typeof waitForReady !== "function") {
+    return extensionBridge.isConnected();
+  }
+  return await waitForReady.call(extensionBridge, EXTENSION_READY_WAIT_MS2);
+};
+var makePermissionsHandler = (schema, action, options) => {
+  return (req, res) => {
+    const parsed = parseBody3(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;
+    }
+    if (!options.extensionBridge) {
+      sendBridgeUnavailable(res);
+      return;
+    }
+    const extensionBridge = options.extensionBridge;
+    void waitForExtensionReady(extensionBridge).then(async (ready) => {
+      if (!ready) {
+        throw new ExtensionBridgeError(
+          "EXTENSION_DISCONNECTED",
+          "Extension is not connected.",
+          true
+        );
+      }
+      return await extensionBridge.request(
+        action,
+        parsed.data
+      );
+    }).then((envelope2) => {
+      if (envelope2.status === "error") {
+        const error = envelope2.error ?? {
+          code: "INTERNAL",
+          message: "Extension request failed.",
+          retryable: false
+        };
+        sendError(res, errorStatus(error.code), {
+          code: error.code,
+          message: error.message,
+          retryable: error.retryable,
+          details: error.details
+        });
+        return;
+      }
+      sendResult(res, envelope2.result ?? {});
+    }).catch((error) => {
+      if (error instanceof ExtensionBridgeError) {
+        sendError(res, errorStatus(error.code), {
+          code: error.code,
+          message: error.message,
+          retryable: error.retryable,
+          details: error.details
+        });
+        return;
+      }
+      sendError(res, errorStatus("INTERNAL"), {
+        code: "INTERNAL",
+        message: "Unexpected permissions route error.",
+        retryable: false,
+        details: {
+          hint: error instanceof Error ? error.message : "Unknown error.",
+          action
+        }
+      });
+    });
+  };
+};
+var registerPermissionsRoutes = (router, options) => {
+  router.post(
+    "/permissions/list",
+    makePermissionsHandler(
+      PermissionsListInputSchema,
+      "permissions.list",
+      options
+    )
+  );
+  router.post(
+    "/permissions/get_mode",
+    makePermissionsHandler(
+      PermissionsGetModeInputSchema,
+      "permissions.get_mode",
+      options
+    )
+  );
+  router.post(
+    "/permissions/list_pending_requests",
+    makePermissionsHandler(
+      PermissionsListPendingRequestsInputSchema,
+      "permissions.list_pending_requests",
+      options
+    )
+  );
+  router.post(
+    "/permissions/request_allow_site",
+    makePermissionsHandler(
+      PermissionsRequestAllowSiteInputSchema,
+      "permissions.request_allow_site",
+      options
+    )
+  );
+  router.post(
+    "/permissions/request_revoke_site",
+    makePermissionsHandler(
+      PermissionsRequestRevokeSiteInputSchema,
+      "permissions.request_revoke_site",
+      options
+    )
+  );
+  router.post(
+    "/permissions/request_set_mode",
+    makePermissionsHandler(
+      PermissionsRequestSetModeInputSchema,
+      "permissions.request_set_mode",
+      options
+    )
+  );
+};
+
 // packages/core/src/recovery.ts
 var RecoveryTracker = class {
   constructor() {
@@ -6446,6 +7103,9 @@ var createCoreServer = (options = {}) => {
     })
   );
   registerDriveRoutes(app, { drive, registry });
+  registerPermissionsRoutes(app, {
+    extensionBridge
+  });
   registerInspectRoutes(app, {
     registry,
     extensionBridge,
@@ -6857,6 +7517,10 @@ var readSessionId2 = (args) => {
   const sessionId = args.session_id;
   return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : void 0;
 };
+var withPermissionsSource = (source) => (args) => isRecord3(args) ? {
+  ...args,
+  source
+} : args;
 var supportsSessionMigration = (corePath) => corePath.startsWith("/drive/") || corePath.startsWith("/inspect/") || corePath.startsWith("/artifacts/") || corePath === "/diagnostics/doctor";
 var isSessionNotFoundEnvelope = (envelopeResult) => {
   if (envelopeResult.ok) {
@@ -6970,6 +7634,69 @@ var TOOL_DEFINITIONS = [
       corePath: "/session/close"
     }
   },
+  {
+    name: "permissions.list",
+    config: {
+      title: "Permissions List",
+      description: "List allowlisted Browser Bridge sites.",
+      inputSchema: PermissionsListInputSchema,
+      outputSchema: envelope(PermissionsListOutputSchema),
+      corePath: "/permissions/list"
+    }
+  },
+  {
+    name: "permissions.get_mode",
+    config: {
+      title: "Permissions Get Mode",
+      description: "Read the current Browser Bridge permissions mode.",
+      inputSchema: PermissionsGetModeInputSchema,
+      outputSchema: envelope(PermissionsGetModeOutputSchema),
+      corePath: "/permissions/get_mode"
+    }
+  },
+  {
+    name: "permissions.list_pending_requests",
+    config: {
+      title: "Permissions List Pending Requests",
+      description: "List pending external Browser Bridge permission-change requests.",
+      inputSchema: PermissionsListPendingRequestsInputSchema,
+      outputSchema: envelope(PermissionsListPendingRequestsOutputSchema),
+      corePath: "/permissions/list_pending_requests"
+    }
+  },
+  {
+    name: "permissions.request_allow_site",
+    config: {
+      title: "Permissions Request Allow Site",
+      description: "Request allowlisting a site. A human must approve the change in Chrome before it applies.",
+      inputSchema: PermissionsRequestAllowSiteInputSchema,
+      outputSchema: envelope(PermissionsRequestOutputSchema),
+      corePath: "/permissions/request_allow_site",
+      transformInput: withPermissionsSource("mcp")
+    }
+  },
+  {
+    name: "permissions.request_revoke_site",
+    config: {
+      title: "Permissions Request Revoke Site",
+      description: "Request revoking a site from the allowlist. A human must approve the change in Chrome before it applies.",
+      inputSchema: PermissionsRequestRevokeSiteInputSchema,
+      outputSchema: envelope(PermissionsRequestOutputSchema),
+      corePath: "/permissions/request_revoke_site",
+      transformInput: withPermissionsSource("mcp")
+    }
+  },
+  {
+    name: "permissions.request_set_mode",
+    config: {
+      title: "Permissions Request Set Mode",
+      description: "Request changing Browser Bridge permission mode. A human must approve the change in Chrome before it applies.",
+      inputSchema: PermissionsRequestSetModeInputSchema,
+      outputSchema: envelope(PermissionsRequestOutputSchema),
+      corePath: "/permissions/request_set_mode",
+      transformInput: withPermissionsSource("mcp")
+    }
+  },
   {
     name: "drive.navigate",
     config: {