@hanzo/browser-extension 1.9.31 → 1.9.33

package/dist/browser-extension/background-firefox.js

@@ -1,4556 +0,0 @@
-"use strict";
-(() => {
-  var __create = Object.create;
-  var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __getProtoOf = Object.getPrototypeOf;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
-  var __copyProps = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp.call(to, key) && key !== except)
-          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-    }
-    return to;
-  };
-  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-    // If the importer is in node compatibility mode or this is not an ESM
-    // file that has been converted to a CommonJS file using a Babel-
-    // compatible transform (i.e. "__esModule" has not been set), then set
-    // "default" to the CommonJS "module.exports" for node compatibility.
-    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-    mod
-  ));
-
-  // ../../node_modules/.pnpm/webextension-polyfill@0.12.0/node_modules/webextension-polyfill/dist/browser-polyfill.js
-  var require_browser_polyfill = __commonJS({
-    "../../node_modules/.pnpm/webextension-polyfill@0.12.0/node_modules/webextension-polyfill/dist/browser-polyfill.js"(exports, module) {
-      (function(global, factory) {
-        if (typeof define === "function" && define.amd) {
-          define("webextension-polyfill", ["module"], factory);
-        } else if (typeof exports !== "undefined") {
-          factory(module);
-        } else {
-          var mod = {
-            exports: {}
-          };
-          factory(mod);
-          global.browser = mod.exports;
-        }
-      })(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : exports, function(module2) {
-        "use strict";
-        if (!(globalThis.chrome && globalThis.chrome.runtime && globalThis.chrome.runtime.id)) {
-          throw new Error("This script should only be loaded in a browser extension.");
-        }
-        if (!(globalThis.browser && globalThis.browser.runtime && globalThis.browser.runtime.id)) {
-          const CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE = "The message port closed before a response was received.";
-          const wrapAPIs = (extensionAPIs) => {
-            const apiMetadata = {
-              "alarms": {
-                "clear": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "clearAll": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "get": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "getAll": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                }
-              },
-              "bookmarks": {
-                "create": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "get": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getChildren": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getRecent": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getSubTree": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getTree": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "move": {
-                  "minArgs": 2,
-                  "maxArgs": 2
-                },
-                "remove": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removeTree": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "search": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "update": {
-                  "minArgs": 2,
-                  "maxArgs": 2
-                }
-              },
-              "browserAction": {
-                "disable": {
-                  "minArgs": 0,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                },
-                "enable": {
-                  "minArgs": 0,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                },
-                "getBadgeBackgroundColor": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getBadgeText": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getPopup": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getTitle": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "openPopup": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "setBadgeBackgroundColor": {
-                  "minArgs": 1,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                },
-                "setBadgeText": {
-                  "minArgs": 1,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                },
-                "setIcon": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "setPopup": {
-                  "minArgs": 1,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                },
-                "setTitle": {
-                  "minArgs": 1,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                }
-              },
-              "browsingData": {
-                "remove": {
-                  "minArgs": 2,
-                  "maxArgs": 2
-                },
-                "removeCache": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removeCookies": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removeDownloads": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removeFormData": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removeHistory": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removeLocalStorage": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removePasswords": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removePluginData": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "settings": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                }
-              },
-              "commands": {
-                "getAll": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                }
-              },
-              "contextMenus": {
-                "remove": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removeAll": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "update": {
-                  "minArgs": 2,
-                  "maxArgs": 2
-                }
-              },
-              "cookies": {
-                "get": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getAll": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getAllCookieStores": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "remove": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "set": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                }
-              },
-              "devtools": {
-                "inspectedWindow": {
-                  "eval": {
-                    "minArgs": 1,
-                    "maxArgs": 2,
-                    "singleCallbackArg": false
-                  }
-                },
-                "panels": {
-                  "create": {
-                    "minArgs": 3,
-                    "maxArgs": 3,
-                    "singleCallbackArg": true
-                  },
-                  "elements": {
-                    "createSidebarPane": {
-                      "minArgs": 1,
-                      "maxArgs": 1
-                    }
-                  }
-                }
-              },
-              "downloads": {
-                "cancel": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "download": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "erase": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getFileIcon": {
-                  "minArgs": 1,
-                  "maxArgs": 2
-                },
-                "open": {
-                  "minArgs": 1,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                },
-                "pause": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removeFile": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "resume": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "search": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "show": {
-                  "minArgs": 1,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                }
-              },
-              "extension": {
-                "isAllowedFileSchemeAccess": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "isAllowedIncognitoAccess": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                }
-              },
-              "history": {
-                "addUrl": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "deleteAll": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "deleteRange": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "deleteUrl": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getVisits": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "search": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                }
-              },
-              "i18n": {
-                "detectLanguage": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getAcceptLanguages": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                }
-              },
-              "identity": {
-                "launchWebAuthFlow": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                }
-              },
-              "idle": {
-                "queryState": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                }
-              },
-              "management": {
-                "get": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getAll": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "getSelf": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "setEnabled": {
-                  "minArgs": 2,
-                  "maxArgs": 2
-                },
-                "uninstallSelf": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                }
-              },
-              "notifications": {
-                "clear": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "create": {
-                  "minArgs": 1,
-                  "maxArgs": 2
-                },
-                "getAll": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "getPermissionLevel": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "update": {
-                  "minArgs": 2,
-                  "maxArgs": 2
-                }
-              },
-              "pageAction": {
-                "getPopup": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getTitle": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "hide": {
-                  "minArgs": 1,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                },
-                "setIcon": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "setPopup": {
-                  "minArgs": 1,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                },
-                "setTitle": {
-                  "minArgs": 1,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                },
-                "show": {
-                  "minArgs": 1,
-                  "maxArgs": 1,
-                  "fallbackToNoCallback": true
-                }
-              },
-              "permissions": {
-                "contains": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getAll": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "remove": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "request": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                }
-              },
-              "runtime": {
-                "getBackgroundPage": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "getPlatformInfo": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "openOptionsPage": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "requestUpdateCheck": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "sendMessage": {
-                  "minArgs": 1,
-                  "maxArgs": 3
-                },
-                "sendNativeMessage": {
-                  "minArgs": 2,
-                  "maxArgs": 2
-                },
-                "setUninstallURL": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                }
-              },
-              "sessions": {
-                "getDevices": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "getRecentlyClosed": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "restore": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                }
-              },
-              "storage": {
-                "local": {
-                  "clear": {
-                    "minArgs": 0,
-                    "maxArgs": 0
-                  },
-                  "get": {
-                    "minArgs": 0,
-                    "maxArgs": 1
-                  },
-                  "getBytesInUse": {
-                    "minArgs": 0,
-                    "maxArgs": 1
-                  },
-                  "remove": {
-                    "minArgs": 1,
-                    "maxArgs": 1
-                  },
-                  "set": {
-                    "minArgs": 1,
-                    "maxArgs": 1
-                  }
-                },
-                "managed": {
-                  "get": {
-                    "minArgs": 0,
-                    "maxArgs": 1
-                  },
-                  "getBytesInUse": {
-                    "minArgs": 0,
-                    "maxArgs": 1
-                  }
-                },
-                "sync": {
-                  "clear": {
-                    "minArgs": 0,
-                    "maxArgs": 0
-                  },
-                  "get": {
-                    "minArgs": 0,
-                    "maxArgs": 1
-                  },
-                  "getBytesInUse": {
-                    "minArgs": 0,
-                    "maxArgs": 1
-                  },
-                  "remove": {
-                    "minArgs": 1,
-                    "maxArgs": 1
-                  },
-                  "set": {
-                    "minArgs": 1,
-                    "maxArgs": 1
-                  }
-                }
-              },
-              "tabs": {
-                "captureVisibleTab": {
-                  "minArgs": 0,
-                  "maxArgs": 2
-                },
-                "create": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "detectLanguage": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "discard": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "duplicate": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "executeScript": {
-                  "minArgs": 1,
-                  "maxArgs": 2
-                },
-                "get": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getCurrent": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                },
-                "getZoom": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "getZoomSettings": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "goBack": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "goForward": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "highlight": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "insertCSS": {
-                  "minArgs": 1,
-                  "maxArgs": 2
-                },
-                "move": {
-                  "minArgs": 2,
-                  "maxArgs": 2
-                },
-                "query": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "reload": {
-                  "minArgs": 0,
-                  "maxArgs": 2
-                },
-                "remove": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "removeCSS": {
-                  "minArgs": 1,
-                  "maxArgs": 2
-                },
-                "sendMessage": {
-                  "minArgs": 2,
-                  "maxArgs": 3
-                },
-                "setZoom": {
-                  "minArgs": 1,
-                  "maxArgs": 2
-                },
-                "setZoomSettings": {
-                  "minArgs": 1,
-                  "maxArgs": 2
-                },
-                "update": {
-                  "minArgs": 1,
-                  "maxArgs": 2
-                }
-              },
-              "topSites": {
-                "get": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                }
-              },
-              "webNavigation": {
-                "getAllFrames": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "getFrame": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                }
-              },
-              "webRequest": {
-                "handlerBehaviorChanged": {
-                  "minArgs": 0,
-                  "maxArgs": 0
-                }
-              },
-              "windows": {
-                "create": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "get": {
-                  "minArgs": 1,
-                  "maxArgs": 2
-                },
-                "getAll": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "getCurrent": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "getLastFocused": {
-                  "minArgs": 0,
-                  "maxArgs": 1
-                },
-                "remove": {
-                  "minArgs": 1,
-                  "maxArgs": 1
-                },
-                "update": {
-                  "minArgs": 2,
-                  "maxArgs": 2
-                }
-              }
-            };
-            if (Object.keys(apiMetadata).length === 0) {
-              throw new Error("api-metadata.json has not been included in browser-polyfill");
-            }
-            class DefaultWeakMap extends WeakMap {
-              constructor(createItem, items = void 0) {
-                super(items);
-                this.createItem = createItem;
-              }
-              get(key) {
-                if (!this.has(key)) {
-                  this.set(key, this.createItem(key));
-                }
-                return super.get(key);
-              }
-            }
-            const isThenable = (value) => {
-              return value && typeof value === "object" && typeof value.then === "function";
-            };
-            const makeCallback = (promise, metadata) => {
-              return (...callbackArgs) => {
-                if (extensionAPIs.runtime.lastError) {
-                  promise.reject(new Error(extensionAPIs.runtime.lastError.message));
-                } else if (metadata.singleCallbackArg || callbackArgs.length <= 1 && metadata.singleCallbackArg !== false) {
-                  promise.resolve(callbackArgs[0]);
-                } else {
-                  promise.resolve(callbackArgs);
-                }
-              };
-            };
-            const pluralizeArguments = (numArgs) => numArgs == 1 ? "argument" : "arguments";
-            const wrapAsyncFunction = (name, metadata) => {
-              return function asyncFunctionWrapper(target, ...args) {
-                if (args.length < metadata.minArgs) {
-                  throw new Error(`Expected at least ${metadata.minArgs} ${pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`);
-                }
-                if (args.length > metadata.maxArgs) {
-                  throw new Error(`Expected at most ${metadata.maxArgs} ${pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`);
-                }
-                return new Promise((resolve, reject) => {
-                  if (metadata.fallbackToNoCallback) {
-                    try {
-                      target[name](...args, makeCallback({
-                        resolve,
-                        reject
-                      }, metadata));
-                    } catch (cbError) {
-                      console.warn(`${name} API method doesn't seem to support the callback parameter, falling back to call it without a callback: `, cbError);
-                      target[name](...args);
-                      metadata.fallbackToNoCallback = false;
-                      metadata.noCallback = true;
-                      resolve();
-                    }
-                  } else if (metadata.noCallback) {
-                    target[name](...args);
-                    resolve();
-                  } else {
-                    target[name](...args, makeCallback({
-                      resolve,
-                      reject
-                    }, metadata));
-                  }
-                });
-              };
-            };
-            const wrapMethod = (target, method, wrapper) => {
-              return new Proxy(method, {
-                apply(targetMethod, thisObj, args) {
-                  return wrapper.call(thisObj, target, ...args);
-                }
-              });
-            };
-            let hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);
-            const wrapObject = (target, wrappers = {}, metadata = {}) => {
-              let cache = /* @__PURE__ */ Object.create(null);
-              let handlers = {
-                has(proxyTarget2, prop) {
-                  return prop in target || prop in cache;
-                },
-                get(proxyTarget2, prop, receiver) {
-                  if (prop in cache) {
-                    return cache[prop];
-                  }
-                  if (!(prop in target)) {
-                    return void 0;
-                  }
-                  let value = target[prop];
-                  if (typeof value === "function") {
-                    if (typeof wrappers[prop] === "function") {
-                      value = wrapMethod(target, target[prop], wrappers[prop]);
-                    } else if (hasOwnProperty(metadata, prop)) {
-                      let wrapper = wrapAsyncFunction(prop, metadata[prop]);
-                      value = wrapMethod(target, target[prop], wrapper);
-                    } else {
-                      value = value.bind(target);
-                    }
-                  } else if (typeof value === "object" && value !== null && (hasOwnProperty(wrappers, prop) || hasOwnProperty(metadata, prop))) {
-                    value = wrapObject(value, wrappers[prop], metadata[prop]);
-                  } else if (hasOwnProperty(metadata, "*")) {
-                    value = wrapObject(value, wrappers[prop], metadata["*"]);
-                  } else {
-                    Object.defineProperty(cache, prop, {
-                      configurable: true,
-                      enumerable: true,
-                      get() {
-                        return target[prop];
-                      },
-                      set(value2) {
-                        target[prop] = value2;
-                      }
-                    });
-                    return value;
-                  }
-                  cache[prop] = value;
-                  return value;
-                },
-                set(proxyTarget2, prop, value, receiver) {
-                  if (prop in cache) {
-                    cache[prop] = value;
-                  } else {
-                    target[prop] = value;
-                  }
-                  return true;
-                },
-                defineProperty(proxyTarget2, prop, desc) {
-                  return Reflect.defineProperty(cache, prop, desc);
-                },
-                deleteProperty(proxyTarget2, prop) {
-                  return Reflect.deleteProperty(cache, prop);
-                }
-              };
-              let proxyTarget = Object.create(target);
-              return new Proxy(proxyTarget, handlers);
-            };
-            const wrapEvent = (wrapperMap) => ({
-              addListener(target, listener, ...args) {
-                target.addListener(wrapperMap.get(listener), ...args);
-              },
-              hasListener(target, listener) {
-                return target.hasListener(wrapperMap.get(listener));
-              },
-              removeListener(target, listener) {
-                target.removeListener(wrapperMap.get(listener));
-              }
-            });
-            const onRequestFinishedWrappers = new DefaultWeakMap((listener) => {
-              if (typeof listener !== "function") {
-                return listener;
-              }
-              return function onRequestFinished(req) {
-                const wrappedReq = wrapObject(req, {}, {
-                  getContent: {
-                    minArgs: 0,
-                    maxArgs: 0
-                  }
-                });
-                listener(wrappedReq);
-              };
-            });
-            const onMessageWrappers = new DefaultWeakMap((listener) => {
-              if (typeof listener !== "function") {
-                return listener;
-              }
-              return function onMessage(message, sender, sendResponse) {
-                let didCallSendResponse = false;
-                let wrappedSendResponse;
-                let sendResponsePromise = new Promise((resolve) => {
-                  wrappedSendResponse = function(response) {
-                    didCallSendResponse = true;
-                    resolve(response);
-                  };
-                });
-                let result;
-                try {
-                  result = listener(message, sender, wrappedSendResponse);
-                } catch (err) {
-                  result = Promise.reject(err);
-                }
-                const isResultThenable = result !== true && isThenable(result);
-                if (result !== true && !isResultThenable && !didCallSendResponse) {
-                  return false;
-                }
-                const sendPromisedResult = (promise) => {
-                  promise.then((msg) => {
-                    sendResponse(msg);
-                  }, (error) => {
-                    let message2;
-                    if (error && (error instanceof Error || typeof error.message === "string")) {
-                      message2 = error.message;
-                    } else {
-                      message2 = "An unexpected error occurred";
-                    }
-                    sendResponse({
-                      __mozWebExtensionPolyfillReject__: true,
-                      message: message2
-                    });
-                  }).catch((err) => {
-                    console.error("Failed to send onMessage rejected reply", err);
-                  });
-                };
-                if (isResultThenable) {
-                  sendPromisedResult(result);
-                } else {
-                  sendPromisedResult(sendResponsePromise);
-                }
-                return true;
-              };
-            });
-            const wrappedSendMessageCallback = ({
-              reject,
-              resolve
-            }, reply) => {
-              if (extensionAPIs.runtime.lastError) {
-                if (extensionAPIs.runtime.lastError.message === CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE) {
-                  resolve();
-                } else {
-                  reject(new Error(extensionAPIs.runtime.lastError.message));
-                }
-              } else if (reply && reply.__mozWebExtensionPolyfillReject__) {
-                reject(new Error(reply.message));
-              } else {
-                resolve(reply);
-              }
-            };
-            const wrappedSendMessage = (name, metadata, apiNamespaceObj, ...args) => {
-              if (args.length < metadata.minArgs) {
-                throw new Error(`Expected at least ${metadata.minArgs} ${pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`);
-              }
-              if (args.length > metadata.maxArgs) {
-                throw new Error(`Expected at most ${metadata.maxArgs} ${pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`);
-              }
-              return new Promise((resolve, reject) => {
-                const wrappedCb = wrappedSendMessageCallback.bind(null, {
-                  resolve,
-                  reject
-                });
-                args.push(wrappedCb);
-                apiNamespaceObj.sendMessage(...args);
-              });
-            };
-            const staticWrappers = {
-              devtools: {
-                network: {
-                  onRequestFinished: wrapEvent(onRequestFinishedWrappers)
-                }
-              },
-              runtime: {
-                onMessage: wrapEvent(onMessageWrappers),
-                onMessageExternal: wrapEvent(onMessageWrappers),
-                sendMessage: wrappedSendMessage.bind(null, "sendMessage", {
-                  minArgs: 1,
-                  maxArgs: 3
-                })
-              },
-              tabs: {
-                sendMessage: wrappedSendMessage.bind(null, "sendMessage", {
-                  minArgs: 2,
-                  maxArgs: 3
-                })
-              }
-            };
-            const settingMetadata = {
-              clear: {
-                minArgs: 1,
-                maxArgs: 1
-              },
-              get: {
-                minArgs: 1,
-                maxArgs: 1
-              },
-              set: {
-                minArgs: 1,
-                maxArgs: 1
-              }
-            };
-            apiMetadata.privacy = {
-              network: {
-                "*": settingMetadata
-              },
-              services: {
-                "*": settingMetadata
-              },
-              websites: {
-                "*": settingMetadata
-              }
-            };
-            return wrapObject(extensionAPIs, staticWrappers, apiMetadata);
-          };
-          module2.exports = wrapAPIs(chrome);
-        } else {
-          module2.exports = globalThis.browser;
-        }
-      });
-    }
-  });
-
-  // src/background-firefox.ts
-  var import_webextension_polyfill = __toESM(require_browser_polyfill());
-
-  // src/shared/zap.ts
-  var ZAP_MAGIC = new Uint8Array([90, 65, 80, 1]);
-  var MSG_REQUEST = 16;
-  function encodeZapMessage(type, payload) {
-    const json = JSON.stringify(payload);
-    const encoder = new TextEncoder();
-    const data = encoder.encode(json);
-    const buf = new ArrayBuffer(4 + 1 + 4 + data.length);
-    const view = new DataView(buf);
-    new Uint8Array(buf, 0, 4).set(ZAP_MAGIC);
-    view.setUint8(4, type);
-    view.setUint32(5, data.length, false);
-    new Uint8Array(buf, 9).set(data);
-    return buf;
-  }
-  function createZapManager() {
-    return {
-      state: {
-        connected: false,
-        mcps: [],
-        extensionId: `hanzo-ext-${Date.now().toString(36)}`
-      },
-      connections: /* @__PURE__ */ new Map(),
-      pendingRequests: /* @__PURE__ */ new Map(),
-      requestIdCounter: 0
-    };
-  }
-  function zapRequest(mgr, mcpId, method, params = {}) {
-    const ws = mgr.connections.get(mcpId);
-    if (!ws || ws.readyState !== WebSocket.OPEN) {
-      return Promise.reject(new Error(`MCP ${mcpId} not connected`));
-    }
-    const id = `req-${++mgr.requestIdCounter}`;
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        mgr.pendingRequests.delete(id);
-        reject(new Error(`ZAP request timeout: ${method}`));
-      }, 3e4);
-      mgr.pendingRequests.set(id, {
-        resolve: (r) => {
-          clearTimeout(timer);
-          resolve(r);
-        },
-        reject: (e) => {
-          clearTimeout(timer);
-          reject(e);
-        }
-      });
-      ws.send(encodeZapMessage(MSG_REQUEST, { id, method, params }));
-    });
-  }
-  async function zapCallTool(mgr, name, args = {}, targetMcpId) {
-    if (targetMcpId) {
-      return zapRequest(mgr, targetMcpId, "tools/call", { name, arguments: args });
-    }
-    for (const mcp of mgr.state.mcps) {
-      if (mcp.tools.includes(name)) {
-        return zapRequest(mgr, mcp.id, "tools/call", { name, arguments: args });
-      }
-    }
-    throw new Error(`Tool not found on any ZAP-connected MCP: ${name}`);
-  }
-  function hasZapTool(mgr, name) {
-    return mgr.state.mcps.some((mcp) => mcp.tools.includes(name));
-  }
-  function zapListResources(mgr, mcpId) {
-    return zapRequest(mgr, mcpId, "resources/list");
-  }
-  function zapReadResource(mgr, mcpId, uri) {
-    return zapRequest(mgr, mcpId, "resources/read", { uri });
-  }
-  function zapListPrompts(mgr, mcpId) {
-    return zapRequest(mgr, mcpId, "prompts/list");
-  }
-  function zapGetPrompt(mgr, mcpId, name, args) {
-    return zapRequest(mgr, mcpId, "prompts/get", { name, arguments: args });
-  }
-  function handleZapMessage(action, request, sendResponse, mgr, browserName, version) {
-    switch (action) {
-      case "zap.status":
-        sendResponse({
-          success: true,
-          zap: {
-            connected: mgr.state.connected,
-            mcps: mgr.state.mcps.map((m) => ({
-              id: m.id,
-              name: m.name,
-              url: m.url,
-              toolCount: m.tools.length
-            }))
-          }
-        });
-        return true;
-      case "zap.discover":
-      case "zap.connect":
-        sendResponse({ success: false, error: "native-zap: connection is via the ai.hanzo.zap native host (no discovery)" });
-        return true;
-      case "zap.callTool": {
-        const toolName = request.name || request.tool;
-        const toolArgs = request.args || {};
-        if (!toolName) {
-          sendResponse({ success: false, error: "Missing tool name" });
-          return true;
-        }
-        zapCallTool(mgr, toolName, toolArgs, request.mcpId).then((result) => {
-          sendResponse({ success: true, result });
-        }).catch((e) => {
-          sendResponse({ success: false, error: e.message });
-        });
-        return true;
-      }
-      case "zap.listTools": {
-        const tools = mgr.state.mcps.flatMap(
-          (m) => m.tools.map((t) => ({ name: t, mcpId: m.id, mcpName: m.name }))
-        );
-        sendResponse({ success: true, tools });
-        return true;
-      }
-      case "zap.listResources": {
-        const mcpId = request.mcpId || mgr.state.mcps[0]?.id;
-        if (!mcpId) {
-          sendResponse({ success: false, error: "No MCP connected" });
-          return true;
-        }
-        zapListResources(mgr, mcpId).then((result) => {
-          sendResponse({ success: true, result });
-        }).catch((e) => {
-          sendResponse({ success: false, error: e.message });
-        });
-        return true;
-      }
-      case "zap.readResource": {
-        const mcpId = request.mcpId || mgr.state.mcps[0]?.id;
-        if (!mcpId) {
-          sendResponse({ success: false, error: "No MCP connected" });
-          return true;
-        }
-        if (!request.uri) {
-          sendResponse({ success: false, error: "Missing uri" });
-          return true;
-        }
-        zapReadResource(mgr, mcpId, request.uri).then((result) => {
-          sendResponse({ success: true, result });
-        }).catch((e) => {
-          sendResponse({ success: false, error: e.message });
-        });
-        return true;
-      }
-      case "zap.listPrompts": {
-        const mcpId = request.mcpId || mgr.state.mcps[0]?.id;
-        if (!mcpId) {
-          sendResponse({ success: false, error: "No MCP connected" });
-          return true;
-        }
-        zapListPrompts(mgr, mcpId).then((result) => {
-          sendResponse({ success: true, result });
-        }).catch((e) => {
-          sendResponse({ success: false, error: e.message });
-        });
-        return true;
-      }
-      case "zap.getPrompt": {
-        const mcpId = request.mcpId || mgr.state.mcps[0]?.id;
-        if (!mcpId) {
-          sendResponse({ success: false, error: "No MCP connected" });
-          return true;
-        }
-        if (!request.name) {
-          sendResponse({ success: false, error: "Missing prompt name" });
-          return true;
-        }
-        zapGetPrompt(mgr, mcpId, request.name, request.args).then((result) => {
-          sendResponse({ success: true, result });
-        }).catch((e) => {
-          sendResponse({ success: false, error: e.message });
-        });
-        return true;
-      }
-      default:
-        return false;
-    }
-  }
-
-  // src/shared/native-zap.ts
-  var HELLO = 1;
-  var WELCOME = 2;
-  var ERROR = 7;
-  var ROUTE = 16;
-  var RESPONSE = 17;
-  var ROLE_PROVIDER = 1;
-  function b64encode(bytes) {
-    let s = "";
-    for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i]);
-    return btoa(s);
-  }
-  function b64decode(s) {
-    const bin = atob(s);
-    const u = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; i++) u[i] = bin.charCodeAt(i);
-    return u;
-  }
-  function putU16(a, n) {
-    a.push(n & 255, n >> 8 & 255);
-  }
-  function putStr(a, s) {
-    const b = new TextEncoder().encode(s);
-    putU16(a, b.length);
-    for (let i = 0; i < b.length; i++) a.push(b[i]);
-  }
-  function encodeHello(role, brand, caps) {
-    const a = [role];
-    putStr(a, brand);
-    putU16(a, caps.length);
-    for (const c of caps) putStr(a, c);
-    return new Uint8Array(a);
-  }
-  function decodeCmd(p) {
-    const dv = new DataView(p.buffer, p.byteOffset, p.byteLength);
-    let o = 0;
-    const ml = dv.getUint16(o, true);
-    o += 2;
-    const method = new TextDecoder().decode(p.subarray(o, o + ml));
-    o += ml;
-    const n = dv.getUint16(o, true);
-    o += 2;
-    const params = {};
-    for (let i = 0; i < n; i++) {
-      const kl = dv.getUint16(o, true);
-      o += 2;
-      const k = new TextDecoder().decode(p.subarray(o, o + kl));
-      o += kl;
-      const vl = dv.getUint32(o, true);
-      o += 4;
-      params[k] = new TextDecoder().decode(p.subarray(o, o + vl));
-      o += vl;
-    }
-    return { method, params };
-  }
-  var RECONNECT_MS = 3e3;
-  function connectNativeZap(state, brand, caps, dispatch, log = console.log) {
-    const rt = (typeof browser !== "undefined" ? browser : chrome).runtime;
-    const prior = state.port;
-    state.port = null;
-    if (prior) {
-      try {
-        prior.disconnect();
-      } catch {
-      }
-    }
-    let port;
-    try {
-      port = rt.connectNative("ai.hanzo.zap");
-    } catch (e) {
-      state.connected = false;
-      log("[Hanzo/ZAP] native host ai.hanzo.zap is not installed");
-      return;
-    }
-    state.port = port;
-    const id = state.providerId;
-    const post = (t, to, payload) => port.postMessage({ t, flags: 0, from: id, to, payload: b64encode(payload) });
-    post(HELLO, "", encodeHello(ROLE_PROVIDER, brand, caps));
-    port.onMessage.addListener(async (msg) => {
-      const payload = msg.payload ? b64decode(msg.payload) : new Uint8Array(0);
-      switch (msg.t) {
-        case WELCOME:
-          state.connected = true;
-          log(`[Hanzo/ZAP] native host connected; registered ${id}`);
-          break;
-        case ERROR:
-          log("[Hanzo/ZAP] " + new TextDecoder().decode(payload));
-          break;
-        case ROUTE: {
-          const { method, params } = decodeCmd(payload);
-          let out;
-          try {
-            const r = await dispatch(method, params);
-            const s = typeof r === "string" ? r : JSON.stringify(r ?? null);
-            out = new TextEncoder().encode(s);
-          } catch (e) {
-            out = new TextEncoder().encode("ERR:" + (e?.message || String(e)));
-          }
-          port.postMessage({ t: RESPONSE, flags: 0, from: id, to: msg.from, payload: b64encode(out) });
-          break;
-        }
-        default:
-          break;
-      }
-    });
-    port.onDisconnect.addListener(() => {
-      if (state.port !== port) return;
-      state.connected = false;
-      state.port = null;
-      const err = rt.lastError?.message;
-      log("[Hanzo/ZAP] native host disconnected" + (err ? ": " + err : ""));
-      setTimeout(() => connectNativeZap(state, brand, caps, dispatch, log), RECONNECT_MS);
-    });
-  }
-
-  // src/shared/evaluable.ts
-  function pickEvaluable(params) {
-    const p = params ?? {};
-    const raw = p.expression ?? p.code ?? p.script ?? p.function ?? p.js ?? "";
-    return typeof raw === "string" ? raw : String(raw);
-  }
-  function wrapEvaluable(code) {
-    const t = (code ?? "").trim();
-    if (!t) return "undefined";
-    if (/^(\(?\s*(async\s+)?function\b|\(?\s*\([^)]*\)\s*=>|\(\s*async\b)/.test(t)) return t;
-    const looksStatement = /[;\n]/.test(t) || /^(const|let|var|if|for|while|switch|return|throw|await|try)\b/.test(t);
-    if (!looksStatement) return t;
-    let body = t.replace(/;\s*$/, "");
-    const cut = Math.max(body.lastIndexOf(";"), body.lastIndexOf("\n"));
-    const head = cut >= 0 ? body.slice(0, cut + 1) : "";
-    const last = (cut >= 0 ? body.slice(cut + 1) : body).trim();
-    if (last && !/^(return|const|let|var|if|for|while|switch|throw|}|\/\/)/.test(last)) {
-      body = head + " return " + last;
-    }
-    return `(async()=>{ ${body} })()`;
-  }
-
-  // src/shared/rag.ts
-  var DEFAULT_RAG_TOP_K = 5;
-  async function getRagConfig(storage) {
-    return new Promise((resolve) => {
-      storage.get([
-        "hanzo_rag_endpoint",
-        "hanzo_rag_api_key",
-        "hanzo_rag_kb",
-        "hanzo_rag_top_k",
-        "hanzo_rag_include_tab_context",
-        "hanzo_rag_use_zap"
-      ], (result) => {
-        const parsedTopK = Number.parseInt(String(result.hanzo_rag_top_k ?? DEFAULT_RAG_TOP_K), 10);
-        resolve({
-          endpoint: String(result.hanzo_rag_endpoint || "").trim(),
-          apiKey: String(result.hanzo_rag_api_key || "").trim(),
-          knowledgeBase: String(result.hanzo_rag_kb || "").trim(),
-          topK: Number.isFinite(parsedTopK) ? Math.max(1, Math.min(parsedTopK, 20)) : DEFAULT_RAG_TOP_K,
-          includeTabContext: result.hanzo_rag_include_tab_context !== false,
-          useZapMemory: result.hanzo_rag_use_zap !== false
-        });
-      });
-    });
-  }
-  function normalizeRagSnippets(raw) {
-    if (!raw) return [];
-    const candidates = [];
-    if (Array.isArray(raw)) candidates.push(...raw);
-    if (Array.isArray(raw?.snippets)) candidates.push(...raw.snippets);
-    if (Array.isArray(raw?.documents)) candidates.push(...raw.documents);
-    if (Array.isArray(raw?.items)) candidates.push(...raw.items);
-    if (Array.isArray(raw?.results)) candidates.push(...raw.results);
-    if (Array.isArray(raw?.memories)) candidates.push(...raw.memories);
-    if (Array.isArray(raw?.matches)) candidates.push(...raw.matches);
-    if (!candidates.length && typeof raw?.content === "string") {
-      candidates.push({ content: raw.content, source: raw.source || "memory" });
-    }
-    const snippets = candidates.map((item) => {
-      const content = String(
-        item?.content ?? item?.text ?? item?.snippet ?? item?.body ?? item?.value ?? ""
-      ).trim();
-      if (!content) return null;
-      return {
-        content,
-        title: item?.title ? String(item.title) : void 0,
-        source: item?.source ? String(item.source) : void 0,
-        score: typeof item?.score === "number" ? item.score : void 0,
-        url: item?.url ? String(item.url) : void 0
-      };
-    }).filter((item) => !!item);
-    return snippets.slice(0, 20);
-  }
-  async function queryRagFromZap(params, mgr) {
-    if (!params.useZapMemory || !mgr.state.connected || !hasZapTool(mgr, "memory")) {
-      return [];
-    }
-    const payloads = [
-      {
-        action: "query",
-        query: params.query,
-        top_k: params.topK,
-        limit: params.topK,
-        kb: params.knowledgeBase || void 0,
-        page_context: params.pageContext
-      },
-      {
-        query: params.query,
-        topK: params.topK,
-        limit: params.topK,
-        knowledge_base: params.knowledgeBase || void 0,
-        context: params.pageContext
-      }
-    ];
-    for (const payload of payloads) {
-      try {
-        const raw = await zapCallTool(mgr, "memory", payload, params.mcpId);
-        const snippets = normalizeRagSnippets(raw);
-        if (snippets.length) {
-          return snippets.map((snippet) => ({
-            ...snippet,
-            source: snippet.source || "zap-memory"
-          }));
-        }
-      } catch {
-      }
-    }
-    return [];
-  }
-  async function queryRagFromEndpoint(params) {
-    if (!params.endpoint) return [];
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (params.apiKey) {
-      headers.Authorization = `Bearer ${params.apiKey}`;
-    }
-    const response = await fetch(params.endpoint, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        query: params.query,
-        top_k: params.topK,
-        knowledge_base: params.knowledgeBase || void 0,
-        page_context: params.includeTabContext ? params.pageContext : void 0,
-        source: "hanzo-browser-extension"
-      })
-    });
-    if (!response.ok) {
-      const text = await response.text();
-      throw new Error(`RAG endpoint error ${response.status}: ${text || "Unknown error"}`);
-    }
-    const raw = await response.json();
-    return normalizeRagSnippets(raw).map((snippet) => ({
-      ...snippet,
-      source: snippet.source || "rag-endpoint"
-    }));
-  }
-
-  // src/shared/config.ts
-  var IAM_LOGIN_URL = "https://hanzo.id";
-  var IAM_API_URL = "https://iam.hanzo.ai";
-  var IAM_API_PATH = "/v1/iam";
-  var DEFAULT_CLIENT_ID = "hanzo-browser";
-  var DEFAULT_SCOPES = "openid profile email";
-  var DEFAULT_REDIRECT_URI = "https://hanzo.ai/callback";
-  var STORAGE_KEYS = {
-    accessToken: "hanzo_iam_access_token",
-    refreshToken: "hanzo_iam_refresh_token",
-    idToken: "hanzo_iam_id_token",
-    expiresAt: "hanzo_iam_expires_at",
-    user: "hanzo_iam_user"
-  };
-  var API_BASE_URL = "https://api.hanzo.ai";
-  var KMS_API_URL = "https://kms.hanzo.ai";
-  var LOCAL_PROVIDER_DEFAULTS = {
-    ollama: { name: "Ollama", url: "http://localhost:11434", probePorts: [11434] },
-    lmstudio: { name: "LM Studio", url: "http://localhost:1234/v1", probePorts: [1234] },
-    "hanzo-desktop": { name: "Hanzo Desktop", url: "http://localhost:11435", probePorts: [11435, 9550] },
-    "hanzo-node": { name: "Hanzo Node", url: "http://localhost:3690", probePorts: [3690, 8080] }
-  };
-  var DEFAULT_CDP_BRIDGE_PORT = 9224;
-  var MODEL_CACHE_TTL_MS = 60 * 1e3;
-  var CONFIG_STORAGE_MAP = {
-    iamLoginUrl: { key: "hanzo_config_iam_login_url", fallback: IAM_LOGIN_URL },
-    iamApiUrl: { key: "hanzo_config_iam_api_url", fallback: IAM_API_URL },
-    apiBaseUrl: { key: "hanzo_config_api_base", fallback: API_BASE_URL },
-    kmsApiUrl: { key: "hanzo_config_kms_url", fallback: KMS_API_URL },
-    clientId: { key: "hanzo_config_client_id", fallback: DEFAULT_CLIENT_ID },
-    scopes: { key: "hanzo_config_scopes", fallback: DEFAULT_SCOPES },
-    redirectUri: { key: "hanzo_config_redirect_uri", fallback: DEFAULT_REDIRECT_URI },
-    cdpBridgePort: { key: "hanzo_config_cdp_bridge_port", fallback: DEFAULT_CDP_BRIDGE_PORT }
-  };
-  async function loadRuntimeConfig(storage) {
-    const keys = Object.values(CONFIG_STORAGE_MAP).map((v) => v.key);
-    const result = await storage.get(keys);
-    const config = {};
-    for (const [field, { key, fallback }] of Object.entries(CONFIG_STORAGE_MAP)) {
-      const stored = result[key];
-      if (stored !== void 0 && stored !== null && stored !== "") {
-        config[field] = typeof fallback === "number" ? Number(stored) : String(stored);
-      } else {
-        config[field] = fallback;
-      }
-    }
-    return config;
-  }
-
-  // src/shared/auth.ts
-  function generateRandomString(length) {
-    const array = new Uint8Array(length);
-    crypto.getRandomValues(array);
-    return Array.from(array, (b) => b.toString(36).padStart(2, "0")).join("").slice(0, length);
-  }
-  async function sha256(plain) {
-    return crypto.subtle.digest("SHA-256", new TextEncoder().encode(plain));
-  }
-  function base64UrlEncode(buffer) {
-    const bytes = new Uint8Array(buffer);
-    let binary = "";
-    for (const byte of bytes) binary += String.fromCharCode(byte);
-    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-  }
-  async function generatePkceChallenge() {
-    const codeVerifier = generateRandomString(64);
-    const hash = await sha256(codeVerifier);
-    const codeChallenge = base64UrlEncode(hash);
-    return { codeVerifier, codeChallenge };
-  }
-  var _runtimeConfig = null;
-  async function getRuntimeConfig(storage) {
-    if (!_runtimeConfig) {
-      _runtimeConfig = await loadRuntimeConfig(storage);
-    }
-    return _runtimeConfig;
-  }
-  async function storeTokens(storage, tokens) {
-    const data = {
-      [STORAGE_KEYS.accessToken]: tokens.access_token
-    };
-    if (tokens.refresh_token) data[STORAGE_KEYS.refreshToken] = tokens.refresh_token;
-    if (tokens.id_token) data[STORAGE_KEYS.idToken] = tokens.id_token;
-    if (tokens.expires_in) {
-      data[STORAGE_KEYS.expiresAt] = Date.now() + tokens.expires_in * 1e3;
-    }
-    await storage.set(data);
-  }
-  async function getStoredTokens(storage) {
-    const result = await storage.get([
-      STORAGE_KEYS.accessToken,
-      STORAGE_KEYS.refreshToken,
-      STORAGE_KEYS.expiresAt
-    ]);
-    return {
-      accessToken: result[STORAGE_KEYS.accessToken] || null,
-      refreshToken: result[STORAGE_KEYS.refreshToken] || null,
-      expiresAt: result[STORAGE_KEYS.expiresAt] || null
-    };
-  }
-  function openAuthTab(tabs, authorizeUrl, redirectUriPrefix) {
-    return new Promise((resolve, reject) => {
-      let authTabId;
-      const timeout = setTimeout(() => {
-        cleanup();
-        reject(new Error("Login timed out"));
-      }, 3e5);
-      function cleanup() {
-        clearTimeout(timeout);
-        tabs.onUpdated.removeListener(onTabUpdated);
-        tabs.onRemoved.removeListener(onTabRemoved);
-      }
-      function onTabUpdated(tabId, changeInfo) {
-        if (tabId !== authTabId || !changeInfo.url) return;
-        if (changeInfo.url.startsWith(redirectUriPrefix)) {
-          cleanup();
-          tabs.remove(tabId).catch(() => {
-          });
-          resolve(changeInfo.url);
-        }
-      }
-      function onTabRemoved(tabId) {
-        if (tabId !== authTabId) return;
-        cleanup();
-        reject(new Error("Login cancelled"));
-      }
-      tabs.onUpdated.addListener(onTabUpdated);
-      tabs.onRemoved.addListener(onTabRemoved);
-      tabs.create({ url: authorizeUrl }).then((tab) => {
-        authTabId = tab.id;
-      }).catch((err) => {
-        cleanup();
-        reject(err);
-      });
-    });
-  }
-  async function login(adapter) {
-    const config = await getRuntimeConfig(adapter.storage);
-    const { codeVerifier, codeChallenge } = await generatePkceChallenge();
-    const state = generateRandomString(32);
-    const redirectUri = config.redirectUri;
-    const authorizeUrl = new URL(`${config.iamLoginUrl}${IAM_API_PATH}/oauth/authorize`);
-    authorizeUrl.searchParams.set("client_id", config.clientId);
-    authorizeUrl.searchParams.set("response_type", "code");
-    authorizeUrl.searchParams.set("redirect_uri", redirectUri);
-    authorizeUrl.searchParams.set("code_challenge", codeChallenge);
-    authorizeUrl.searchParams.set("code_challenge_method", "S256");
-    authorizeUrl.searchParams.set("scope", config.scopes);
-    authorizeUrl.searchParams.set("state", state);
-    const callbackUrl = await openAuthTab(adapter.tabs, authorizeUrl.toString(), redirectUri);
-    const url = new URL(callbackUrl);
-    if (url.searchParams.get("state") !== state) throw new Error("State mismatch \u2014 possible CSRF");
-    const code = url.searchParams.get("code");
-    const directToken = url.searchParams.get("access_token");
-    if (directToken) {
-      await storeTokens(adapter.storage, {
-        access_token: directToken,
-        refresh_token: url.searchParams.get("refresh_token") || void 0,
-        token_type: "Bearer"
-      });
-    } else if (code) {
-      const tokenResponse = await fetch(`${config.iamApiUrl}${IAM_API_PATH}/oauth/token`, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({
-          grant_type: "authorization_code",
-          client_id: config.clientId,
-          code,
-          redirect_uri: redirectUri,
-          code_verifier: codeVerifier
-        }).toString()
-      });
-      if (!tokenResponse.ok) throw new Error(`Token exchange failed: ${await tokenResponse.text()}`);
-      await storeTokens(adapter.storage, await tokenResponse.json());
-    } else {
-      const error = url.searchParams.get("error_description") || url.searchParams.get("error") || "No authorization code or token";
-      throw new Error(error);
-    }
-    const { accessToken } = await getStoredTokens(adapter.storage);
-    if (!accessToken) throw new Error("Login succeeded but no token was stored");
-    const user = await fetchUserInfo(adapter.storage, accessToken);
-    await adapter.storage.set({ [STORAGE_KEYS.user]: user });
-    return user;
-  }
-  async function signup(adapter) {
-    const config = await getRuntimeConfig(adapter.storage);
-    await adapter.tabs.create({ url: `${config.iamLoginUrl}/signup` });
-  }
-  async function logout(storage) {
-    await storage.remove(Object.values(STORAGE_KEYS));
-  }
-  async function getValidAccessToken(storage) {
-    const { accessToken, refreshToken, expiresAt } = await getStoredTokens(storage);
-    if (!accessToken) return null;
-    if (expiresAt && Date.now() < expiresAt - 6e4) return accessToken;
-    if (refreshToken) {
-      try {
-        return await refreshAccessToken(storage, refreshToken);
-      } catch {
-        await logout(storage);
-        return null;
-      }
-    }
-    return accessToken;
-  }
-  async function refreshAccessToken(storage, refreshToken) {
-    const config = await getRuntimeConfig(storage);
-    const response = await fetch(`${config.iamApiUrl}${IAM_API_PATH}/oauth/token`, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
-        grant_type: "refresh_token",
-        client_id: config.clientId,
-        refresh_token: refreshToken
-      }).toString()
-    });
-    if (!response.ok) throw new Error("Token refresh failed");
-    const tokens = await response.json();
-    await storeTokens(storage, tokens);
-    return tokens.access_token;
-  }
-  async function fetchUserInfo(storage, accessToken) {
-    const config = await getRuntimeConfig(storage);
-    const headers = { Authorization: `Bearer ${accessToken}` };
-    const response = await fetch(`${config.iamApiUrl}${IAM_API_PATH}/oauth/userinfo`, { headers });
-    if (!response.ok) throw new Error("Failed to fetch user info");
-    return response.json();
-  }
-  async function getUserInfo(storage) {
-    const result = await storage.get([STORAGE_KEYS.user]);
-    return result[STORAGE_KEYS.user] || null;
-  }
-  async function getAuthStatus(storage) {
-    const token = await getValidAccessToken(storage);
-    if (!token) {
-      return { authenticated: false, user: null };
-    }
-    const user = await getUserInfo(storage);
-    return { authenticated: true, user };
-  }
-  function getBrowser() {
-    return globalThis.browser ?? globalThis.chrome;
-  }
-  function webExtensionAdapter() {
-    const b = getBrowser();
-    return {
-      storage: {
-        // Promise-returning on every runtime once the polyfill is loaded.
-        get: (keys) => Promise.resolve(b.storage.local.get(keys)),
-        set: (items) => Promise.resolve(b.storage.local.set(items)),
-        remove: (keys) => Promise.resolve(b.storage.local.remove(keys))
-      },
-      tabs: {
-        create: (opts) => Promise.resolve(b.tabs.create(opts)),
-        remove: (tabId) => Promise.resolve(b.tabs.remove(tabId)),
-        onUpdated: b.tabs.onUpdated,
-        onRemoved: b.tabs.onRemoved
-      }
-    };
-  }
-  function firefoxAdapter() {
-    return webExtensionAdapter();
-  }
-
-  // src/shared/tab-id.ts
-  function parseTabId(raw) {
-    if (typeof raw === "number" && Number.isFinite(raw)) return raw;
-    if (typeof raw !== "string") return null;
-    if (raw === "") return null;
-    const m = raw.match(/^(?:tab-)?(\d+)$/);
-    if (!m) return null;
-    const n = Number(m[1]);
-    return Number.isFinite(n) ? n : null;
-  }
-
-  // src/background-firefox.ts
-  var BROWSER_NAME = "firefox";
-  var VERSION = typeof browser !== "undefined" ? browser.runtime.getManifest().version : "0";
-  var PRIVILEGED_URL_PATTERNS = [
-    /^about:/i,
-    // about:debugging, about:addons, about:config…
-    /^moz-extension:/i,
-    // any extension's own pages
-    /^chrome:/i,
-    // chrome://… (Firefox accepts these too)
-    /^view-source:/i,
-    /^resource:/i,
-    /^file:/i,
-    // local files unless explicit perm granted
-    /^https?:\/\/addons\.mozilla\.org\b/i
-    // AMO blocks WebExtensions by policy
-  ];
-  function isPrivilegedTab(tab) {
-    if (!tab) return false;
-    const url = tab.url || tab.pendingUrl || "";
-    if (!url) {
-      return true;
-    }
-    return PRIVILEGED_URL_PATTERNS.some((rx) => rx.test(url));
-  }
-  var zapMgr = createZapManager();
-  var controlSession = {
-    active: false,
-    tabId: null,
-    task: null,
-    startedAt: null
-  };
-  var HanzoFirefoxExtension = class {
-    constructor() {
-      this.wsConnection = null;
-      this.cdpPort = 9223;
-      this.reconnectTimeout = 3e3;
-      console.log("[Hanzo] Firefox extension initializing...");
-      this.connect();
-    }
-    connect() {
-      const url = `ws://localhost:${this.cdpPort}/cdp`;
-      console.log(`[Hanzo] Connecting to ${url}`);
-      this.wsConnection = new WebSocket(url);
-      this.wsConnection.onopen = () => {
-        console.log("[Hanzo] WebSocket CONNECTED");
-        this.register();
-      };
-      this.wsConnection.onmessage = async (event) => {
-        try {
-          const message = JSON.parse(event.data);
-          if (message.type === "extension-request") {
-            console.log("[Hanzo] Extension request:", message.action);
-            const result = await this.handleExtensionRequest(message.action, message.params || {});
-            this.send({ type: "extension-response", id: message.id, result });
-            return;
-          }
-          console.log("[Hanzo] Received:", message.method || "response");
-          const response = await this.handleCommand(message);
-          this.send(response);
-        } catch (e) {
-          console.error("[Hanzo] Message handler error:", e);
-          this.send({ id: 0, error: { code: -1, message: String(e) } });
-        }
-      };
-      this.wsConnection.onerror = (error) => {
-        console.error("[Hanzo] WebSocket error:", error);
-      };
-      this.wsConnection.onclose = () => {
-        console.log("[Hanzo] Disconnected, reconnecting...");
-        setTimeout(() => this.connect(), this.reconnectTimeout);
-      };
-    }
-    register() {
-      this.send({
-        type: "register",
-        role: "cdp-provider",
-        browser: BROWSER_NAME,
-        // 'firefox'
-        capabilities: [
-          "navigate",
-          "screenshot",
-          "click",
-          "dblclick",
-          "hover",
-          "type",
-          "evaluate",
-          "tabs",
-          "fill",
-          "clear",
-          "reload",
-          "goBack",
-          "goForward",
-          "select",
-          "check",
-          "uncheck",
-          "press_key",
-          "content",
-          "snapshot",
-          "getText",
-          "getHTML",
-          "getAttribute",
-          "getElementInfo",
-          "getPageInfo",
-          "querySelectorAll",
-          "waitForSelector",
-          "waitForNavigation",
-          // CSP-safe text/label primitives + composite waits (1.9.16+)
-          "clickByText",
-          "fillByLabel",
-          "findByText",
-          "listForm",
-          "press",
-          "scroll",
-          "waitForText",
-          "waitForMutation",
-          "submitForm",
-          "uploadFile",
-          "dialogAccept",
-          "observe",
-          "observeRead",
-          "observeStop",
-          // Coordinate-level Input.* (1.9.16+)
-          "Input.dispatchMouseEvent",
-          "Input.scrollWheel",
-          // DOM.* + Page.* aliases (1.9.16+)
-          "DOM.querySelector",
-          "DOM.scrollIntoView",
-          "DOM.focus",
-          "Page.printToPDF",
-          // Existing legacy
-          "fetch",
-          "cookies",
-          "localStorage",
-          "injectScript",
-          "injectCSS",
-          "createTab",
-          "closeTab",
-          "activateTab",
-          "history",
-          "observeMutations",
-          "computedStyles",
-          "boundingRects",
-          "setHTML",
-          "setText",
-          "setAttribute",
-          "removeAttribute",
-          "setStyle",
-          "addClass",
-          "removeClass",
-          "insertElement",
-          "removeElement",
-          "monitor",
-          "audit"
-        ]
-      });
-    }
-    send(data) {
-      if (this.wsConnection?.readyState === WebSocket.OPEN) {
-        this.wsConnection.send(JSON.stringify(data));
-      }
-    }
-    async handleCommand(message) {
-      const { id, method, params = {} } = message;
-      try {
-        const result = await this.executeMethod(method, params);
-        return { id, result };
-      } catch (e) {
-        return { id, error: { code: -1, message: String(e) } };
-      }
-    }
-    /**
-     * Run JS in a page tab and return its result, with a hard timeout.
-     *
-     * Firefox MV3 removed `browser.tabs.executeScript` (the string-based
-     * MV2 API). The replacement is `browser.scripting.executeScript({...})`
-     * which only accepts a function (or files), not a code string. To keep
-     * the existing call sites that pass dynamic strings working, we inject
-     * a one-line trampoline `(c) => Function(c)()` and forward the user's
-     * code as an argument, executing in the page's MAIN world (so the
-     * page's own CSP applies and `Function` is allowed on most sites).
-     *
-     * Falls back to MV2 `tabs.executeScript` on browsers / runtimes that
-     * still have it (older Firefox, Chrome MV2 which we don't ship but
-     * don't want to break).
-     */
-    executeScriptWithTimeout(tabId, code, timeoutMs = 1e4) {
-      const exec = (async () => {
-        const scripting = browser.scripting;
-        if (scripting?.executeScript) {
-          const runIn = async (world) => {
-            const results = await scripting.executeScript({
-              target: { tabId },
-              world,
-              args: [code],
-              func: (codeStr) => {
-                try {
-                  return Function(codeStr)();
-                } catch (e) {
-                  return { __hanzo_error: e?.message || String(e) };
-                }
-              }
-            });
-            return Array.isArray(results) ? results.map((r) => r?.result) : [results];
-          };
-          const main = await runIn("MAIN");
-          const blocked = main.length > 0 && main.every(
-            (r) => r && typeof r === "object" && r.__hanzo_error && /CSP|unsafe-eval|Content Security|Function|eval/i.test(String(r.__hanzo_error))
-          );
-          if (!blocked) return main;
-          return runIn("ISOLATED");
-        }
-        const legacy = browser.tabs?.executeScript;
-        if (legacy) return legacy.call(browser.tabs, tabId, { code });
-        throw new Error("No executeScript API available (need MV3 scripting permission)");
-      })();
-      return Promise.race([
-        exec,
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("executeScript timeout")), timeoutMs)
-        )
-      ]);
-    }
-    /**
-     * Resolve the tab ID to operate on. Order of precedence:
-     *
-     *   1. params.tabId — number, or "tab-NNN" string from getTargets, or "NNN".
-     *   2. params.targetId — same as tabId but kept for CDP-style callers.
-     *   3. params.tabIndex — index into the current window's tab list.
-     *   4. Fall back to the active tab in the current window.
-     *
-     * Without (1) or (2) the bridge always picks the OS-active tab, which is
-     * almost never what an automation client wants when many windows are open.
-     */
-    async resolveTab(params) {
-      const rawId = params.tabId ?? params.targetId;
-      if (rawId !== void 0 && rawId !== null) {
-        const id = parseTabId(rawId);
-        if (id !== null) {
-          try {
-            return await browser.tabs.get(id);
-          } catch {
-          }
-        }
-      }
-      if (typeof params.tabIndex === "number") {
-        const tabs = await browser.tabs.query({ currentWindow: true });
-        const tab = tabs[params.tabIndex];
-        if (tab) return tab;
-      }
-      const [activeTab] = await browser.tabs.query({ active: true, currentWindow: true });
-      if (activeTab) return activeTab;
-      throw new Error("No active tab");
-    }
-    /**
-     * Run JS in the page via executeScript and return the serialized result.
-     * Bumped to throw on empty/missing results so undefined → {} can no
-     * longer hide a privileged-tab or CSP failure (1.9.2).
-     */
-    async runInPage(tabId, code, timeoutMs = 1e4) {
-      let tab;
-      try {
-        tab = await browser.tabs.get(tabId);
-      } catch {
-      }
-      if (tab && isPrivilegedTab(tab)) {
-        throw new Error(
-          `Cannot run JS in privileged tab ${tabId} (${tab.url}). Activate a regular http(s) tab via tabId/tab_id parameter.`
-        );
-      }
-      const wrappedCode = `
-      try {
-        var __r = (function() { ${code} })();
-        return __r === undefined ? null : __r;
-      } catch(__e) {
-        return { __hanzo_error: __e.message || String(__e) };
-      }
-    `;
-      const results = await this.executeScriptWithTimeout(tabId, wrappedCode, timeoutMs);
-      if (!Array.isArray(results) || results.length === 0) {
-        throw new Error(
-          `executeScript returned no frames for tab ${tabId} \u2014 page may be privileged, in a process the extension can't access, or unloaded.`
-        );
-      }
-      const result = results[0];
-      if (result === void 0) {
-        throw new Error(
-          `executeScript ran but returned no value (frame errored outside the wrapped try/catch \u2014 most often page CSP blocking Function()). Tab ${tabId}.`
-        );
-      }
-      if (result && typeof result === "object" && result.__hanzo_error) {
-        throw new Error(result.__hanzo_error);
-      }
-      return result;
-    }
-    /**
-     * CSP-safe alternative to runInPage. Passes a real function reference
-     * (and serializable args) to scripting.executeScript. Because no
-     * Function() or eval() is constructed at runtime, page CSP that
-     * blocks 'unsafe-eval' does NOT block this path. Works on .gov, on
-     * sites that ship strict default-src 'self', and on github.com.
-     *
-     * Use this for any DOM read/write the bridge needs to do. The
-     * `fn` argument is a normal JS function — it is serialized by
-     * Firefox/Chrome's scripting API and executed in the MAIN world.
-     *
-     * Added in 1.9.16 alongside the CDP-shaped decomplected surface.
-     */
-    async runFunc(tabId, fn, args = [], timeoutMs = 1e4) {
-      let tab;
-      try {
-        tab = await browser.tabs.get(tabId);
-      } catch {
-      }
-      if (tab && isPrivilegedTab(tab)) {
-        throw new Error(
-          `Cannot run JS in privileged tab ${tabId} (${tab.url}).`
-        );
-      }
-      const scripting = browser.scripting;
-      if (!scripting?.executeScript) {
-        throw new Error("scripting.executeScript not available (need MV3 scripting permission)");
-      }
-      const exec = (async () => {
-        const runIn = async (world) => {
-          const results = await scripting.executeScript({
-            target: { tabId },
-            world,
-            args,
-            func: fn
-          });
-          return Array.isArray(results) ? results : [results];
-        };
-        let out;
-        try {
-          out = await runIn("MAIN");
-        } catch (e) {
-          out = await runIn("ISOLATED");
-        }
-        if (!Array.isArray(out) || out.length === 0) {
-          throw new Error(
-            `runFunc returned no frames for tab ${tabId} \u2014 page may be privileged or unloaded.`
-          );
-        }
-        const first = out[0] || {};
-        if (first.error) {
-          throw new Error(`runFunc page-side error: ${first.error}`);
-        }
-        const result = first.result;
-        if (result && typeof result === "object" && result.__hanzo_error) {
-          throw new Error(result.__hanzo_error);
-        }
-        return result === void 0 ? null : result;
-      })();
-      return Promise.race([
-        exec,
-        new Promise((_, reject) => setTimeout(() => reject(new Error("runFunc timeout")), timeoutMs))
-      ]);
-    }
-    /**
-     * Public dispatcher for ZAP-server-initiated requests. Mirrors
-     * `CDPBridge.dispatchMethod` on the Chrome side so background-ZAP wiring
-     * is symmetric across browsers. Calls into the same canonical
-     * ``executeMethod`` switch already used by the legacy WS path.
-     */
-    async dispatchMethod(method, params) {
-      const result = await this.executeMethod(method, params || {});
-      if (result && typeof result === "object" && "error" in result && result.error) {
-        const err = new Error(String(result.error));
-        throw err;
-      }
-      return result;
-    }
-    async executeMethod(method, params) {
-      let tab;
-      try {
-        tab = await this.resolveTab(params);
-      } catch {
-        tab = null;
-      }
-      const tabId = tab?.id ?? void 0;
-      switch (method) {
-        // =====================================================================
-        // Target / Tab management
-        // =====================================================================
-        case "Target.getTargets": {
-          const allTabs = await browser.tabs.query({});
-          return {
-            targetInfos: allTabs.map((t) => ({
-              targetId: `tab-${t.id}`,
-              type: "page",
-              title: t.title || "",
-              url: t.url || ""
-            }))
-          };
-        }
-        case "Target.createTarget": {
-          const newTab = await browser.tabs.create({ url: params.url || "about:blank" });
-          return { targetId: `tab-${newTab.id}`, tabId: newTab.id };
-        }
-        case "Target.closeTarget": {
-          const closeId = parseTabId(params.targetId ?? params.tabId);
-          if (closeId !== null) await browser.tabs.remove(closeId);
-          return { success: true };
-        }
-        case "Target.activateTarget": {
-          const activateId = parseTabId(params.targetId ?? params.tabId);
-          if (activateId !== null) await browser.tabs.update(activateId, { active: true });
-          return { success: true };
-        }
-        // =====================================================================
-        // Tab info — native APIs, never block on page content
-        // =====================================================================
-        case "hanzo.url": {
-          return { result: { value: tab?.url || "" } };
-        }
-        case "hanzo.title": {
-          return { result: { value: tab?.title || "" } };
-        }
-        case "hanzo.tabInfo": {
-          return {
-            result: {
-              value: {
-                id: tab?.id,
-                url: tab?.url,
-                title: tab?.title,
-                status: tab?.status,
-                favIconUrl: tab?.favIconUrl
-              }
-            }
-          };
-        }
-        case "hanzo.getTabs":
-        case "hanzo.listTabs": {
-          const tabs = await browser.tabs.query({});
-          return {
-            tabs: tabs.map((t) => ({
-              id: t.id,
-              url: t.url,
-              title: t.title,
-              active: t.active
-            }))
-          };
-        }
-        case "hanzo.getHistory": {
-          const maxResults = params.maxResults || 25;
-          try {
-            const items = await browser.history.search({ text: "", maxResults, startTime: 0 });
-            return { history: items.map((h) => ({ url: h.url, title: h.title, lastVisitTime: h.lastVisitTime })) };
-          } catch {
-            return { history: [], error: "history API not available" };
-          }
-        }
-        // =====================================================================
-        // Navigation
-        // =====================================================================
-        case "Page.navigate": {
-          if (!tabId) throw new Error("No active tab");
-          this.notifyOverlay(tabId, "ai.control.status", { text: `Navigating to ${params.url}` });
-          await browser.tabs.update(tabId, { url: params.url });
-          return { frameId: "main" };
-        }
-        case "Page.reload": {
-          if (!tabId) throw new Error("No active tab");
-          await browser.tabs.reload(tabId);
-          return { success: true };
-        }
-        case "Page.goBack": {
-          if (!tabId) throw new Error("No active tab");
-          await browser.tabs.goBack(tabId);
-          return { success: true };
-        }
-        case "Page.goForward": {
-          if (!tabId) throw new Error("No active tab");
-          await browser.tabs.goForward(tabId);
-          return { success: true };
-        }
-        case "hanzo.waitForNavigation": {
-          if (!tabId) throw new Error("No active tab");
-          const navTimeout = params.timeout || 3e4;
-          return new Promise((resolve) => {
-            let done = false;
-            const timer = setTimeout(() => {
-              if (!done) {
-                done = true;
-                browser.webNavigation.onCompleted.removeListener(onNav);
-                resolve({ success: false, error: "timeout" });
-              }
-            }, navTimeout);
-            function onNav(details) {
-              if (details.tabId === tabId && details.frameId === 0) {
-                done = true;
-                clearTimeout(timer);
-                browser.webNavigation.onCompleted.removeListener(onNav);
-                resolve({ success: true, url: details.url });
-              }
-            }
-            browser.webNavigation.onCompleted.addListener(onNav);
-          });
-        }
-        case "Page.waitForLoadState": {
-          if (!tabId) throw new Error("No active tab");
-          const loadTimeout = params.timeout || 3e4;
-          const start = Date.now();
-          while (Date.now() - start < loadTimeout) {
-            const t = await browser.tabs.get(tabId);
-            if (t.status === "complete") return { success: true };
-            await new Promise((r) => setTimeout(r, 200));
-          }
-          return { success: false, error: "timeout" };
-        }
-        // =====================================================================
-        // JavaScript evaluation
-        // =====================================================================
-        case "Runtime.evaluate":
-        case "evaluate": {
-          if (!tabId) throw new Error("No active tab");
-          const timeout = params.timeout || 3e4;
-          const evalCode = `
-          return Promise.resolve(${wrapEvaluable(pickEvaluable(params))}).then(function(__v){
-            if (__v === undefined || __v === null) return null;
-            try { return JSON.parse(JSON.stringify(__v)); } catch(e) { return String(__v); }
-          }, function(__e){
-            return { __hanzo_error: (__e && __e.message) || String(__e) };
-          });
-        `;
-          let value;
-          let evalError = null;
-          try {
-            value = await this.runInPage(tabId, evalCode, timeout);
-          } catch (e) {
-            evalError = e?.message || String(e);
-            value = null;
-          }
-          const safeValue = value === void 0 ? null : value;
-          const cdpType = safeValue === null ? "object" : Array.isArray(safeValue) ? "object" : typeof safeValue;
-          const out = {
-            result: { type: cdpType, value: safeValue },
-            value: safeValue
-          };
-          if (evalError !== null) {
-            out.error = evalError;
-            out.result = {
-              type: "object",
-              value: null,
-              subtype: "error",
-              description: evalError
-            };
-            out.exceptionDetails = { text: evalError };
-          }
-          return out;
-        }
-        // =====================================================================
-        // Screenshots
-        //
-        // Firefox is strict about the captureVisibleTab signature: it wants
-        // `(windowId, options)`. The Chrome MV3 polyfill accepted just
-        // `(options)` so a lot of cross-browser code passes opts as the first
-        // arg, which Firefox interprets as a windowId integer and silently
-        // returns the empty string. Resolve the *target* tab's windowId
-        // explicitly so the screenshot is always of the right window.
-        // =====================================================================
-        case "Page.captureScreenshot":
-        case "hanzo.screenshot": {
-          const format = params.format || "jpeg";
-          const quality = params.quality || (format === "jpeg" ? 80 : void 0);
-          const opts = { format };
-          if (quality !== void 0) opts.quality = quality;
-          let activatedFor = null;
-          let prevActiveId;
-          if (tab && !tab.active) {
-            const [prev] = await browser.tabs.query({ active: true, windowId: tab.windowId });
-            prevActiveId = prev?.id;
-            await browser.tabs.update(tab.id, { active: true });
-            activatedFor = tab.id ?? null;
-            await new Promise((r) => setTimeout(r, 50));
-          }
-          let dataUrl;
-          try {
-            dataUrl = await browser.tabs.captureVisibleTab(tab?.windowId ?? null, opts);
-          } finally {
-            if (activatedFor !== null && prevActiveId) {
-              await browser.tabs.update(prevActiveId, { active: true }).catch(() => {
-              });
-            }
-          }
-          if (!dataUrl) throw new Error("captureVisibleTab returned empty result");
-          const base64 = dataUrl.replace(/^data:image\/\w+;base64,/, "");
-          return { data: base64, format, size: base64.length };
-        }
-        // =====================================================================
-        // Accessibility snapshot
-        // =====================================================================
-        case "Accessibility.getFullAXTree": {
-          if (!tabId) throw new Error("No active tab");
-          const tree = await this.runInPage(tabId, `
-          function buildTree(el, depth) {
-            if (depth > 5 || !el) return null;
-            var role = el.getAttribute && el.getAttribute('role') || el.tagName?.toLowerCase() || '';
-            var name = el.getAttribute && (el.getAttribute('aria-label') || el.getAttribute('alt') || el.getAttribute('title') || el.textContent?.trim()?.slice(0, 80)) || '';
-            var node = { role: role, name: name };
-            if (el.children && el.children.length > 0 && depth < 5) {
-              node.children = [];
-              for (var i = 0; i < Math.min(el.children.length, 50); i++) {
-                var child = buildTree(el.children[i], depth + 1);
-                if (child) node.children.push(child);
-              }
-            }
-            return node;
-          }
-          return buildTree(document.body, 0);
-        `);
-          return { tree };
-        }
-        // =====================================================================
-        // Click / Interaction
-        // =====================================================================
-        case "hanzo.click": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          this.notifyOverlay(tabId, "ai.control.highlight", { selector: params.selector });
-          this.notifyOverlay(tabId, "ai.control.status", { text: `Clicking ${params.selector}` });
-          const result = await this.runFunc(tabId, (selector) => {
-            const el = document.querySelector(selector);
-            if (!el) return { clicked: false, reason: "not-found" };
-            try {
-              el.scrollIntoView({ block: "center", behavior: "instant" });
-            } catch (e) {
-            }
-            const r = el.getBoundingClientRect();
-            const x = r.left + r.width / 2;
-            const y = r.top + r.height / 2;
-            const init = {
-              bubbles: true,
-              cancelable: true,
-              composed: true,
-              view: window,
-              button: 0,
-              buttons: 1,
-              clientX: x,
-              clientY: y,
-              screenX: x,
-              screenY: y,
-              detail: 1
-            };
-            try {
-              el.dispatchEvent(new MouseEvent("mouseover", init));
-              el.dispatchEvent(new MouseEvent("mouseenter", init));
-              el.dispatchEvent(new MouseEvent("mousemove", init));
-              el.dispatchEvent(new MouseEvent("mousedown", init));
-              try {
-                el.focus({ preventScroll: true });
-              } catch (e) {
-              }
-              el.dispatchEvent(new MouseEvent("mouseup", { ...init, buttons: 0 }));
-              el.dispatchEvent(new MouseEvent("click", { ...init, buttons: 0 }));
-              return { clicked: true, tag: el.tagName, x, y, isTrusted: false };
-            } catch (e) {
-              try {
-                el.click();
-                return { clicked: true, fallback: "el.click()", isTrusted: false };
-              } catch (e2) {
-                return { clicked: false, error: String(e2) };
-              }
-            }
-          }, [params.selector]);
-          return { success: !!(result && result.clicked), detail: result };
-        }
-        case "hanzo.dblclick": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          this.notifyOverlay(tabId, "ai.control.highlight", { selector: params.selector });
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) {
-            el.dispatchEvent(new MouseEvent('dblclick', {bubbles: true, cancelable: true}));
-          }
-        `);
-          return { success: true };
-        }
-        case "hanzo.hover": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          this.notifyOverlay(tabId, "ai.control.highlight", { selector: params.selector });
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) {
-            el.dispatchEvent(new MouseEvent('mouseenter', {bubbles: true}));
-            el.dispatchEvent(new MouseEvent('mouseover', {bubbles: true}));
-            el.dispatchEvent(new MouseEvent('mousemove', {bubbles: true}));
-          }
-        `);
-          return { success: true };
-        }
-        // =====================================================================
-        // Form input
-        // =====================================================================
-        case "hanzo.fill": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          this.notifyOverlay(tabId, "ai.control.highlight", { selector: params.selector });
-          this.notifyOverlay(tabId, "ai.control.status", { text: `Filling ${params.selector}` });
-          const ok = await this.runFunc(tabId, (selector, value) => {
-            const el = document.querySelector(selector);
-            if (!el) return false;
-            try {
-              el.scrollIntoView({ block: "center", behavior: "instant" });
-            } catch (e) {
-            }
-            try {
-              el.focus();
-            } catch (e) {
-            }
-            const tag = el.tagName;
-            if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") {
-              let setter = null;
-              try {
-                if (tag === "TEXTAREA") {
-                  setter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, "value")?.set;
-                } else if (tag === "INPUT") {
-                  setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, "value")?.set;
-                } else if (tag === "SELECT") {
-                  setter = Object.getOwnPropertyDescriptor(window.HTMLSelectElement.prototype, "value")?.set;
-                }
-              } catch (e) {
-                setter = null;
-              }
-              try {
-                if (setter) setter.call(el, value);
-                else el.value = value;
-              } catch (e) {
-                el.value = value;
-              }
-              el.dispatchEvent(new Event("input", { bubbles: true }));
-              el.dispatchEvent(new Event("change", { bubbles: true }));
-              return true;
-            }
-            if (el.isContentEditable) {
-              el.textContent = value;
-              el.dispatchEvent(new Event("input", { bubbles: true }));
-              return true;
-            }
-            return false;
-          }, [params.selector, params.value || ""]);
-          return { success: !!ok };
-        }
-        case "hanzo.type": {
-          if (!tabId) throw new Error("No active tab");
-          const text = this.escapeValue(params.text || "");
-          const typeSel = params.selector ? this.escapeSelector(params.selector) : null;
-          await this.runInPage(tabId, `
-          var el = ${typeSel ? `document.querySelector('${typeSel}')` : "document.activeElement"};
-          if (el && (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.isContentEditable)) {
-            el.focus();
-            if (el.isContentEditable) {
-              document.execCommand('insertText', false, '${text}');
-            } else {
-              el.value += '${text}';
-              el.dispatchEvent(new Event('input', {bubbles: true}));
-            }
-          }
-        `);
-          return { success: true };
-        }
-        case "hanzo.clear": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const ok = await this.runFunc(tabId, (selector) => {
-            const el = document.querySelector(selector);
-            if (!el) return false;
-            const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, "value")?.set || Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, "value")?.set;
-            if (setter) setter.call(el, "");
-            else el.value = "";
-            el.dispatchEvent(new Event("input", { bubbles: true }));
-            el.dispatchEvent(new Event("change", { bubbles: true }));
-            return true;
-          }, [params.selector]);
-          return { success: !!ok };
-        }
-        case "hanzo.select": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          const optVal = this.escapeValue(params.value || "");
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el && el.tagName === 'SELECT') {
-            el.value = '${optVal}';
-            el.dispatchEvent(new Event('change', {bubbles: true}));
-          }
-        `);
-          return { success: true };
-        }
-        case "hanzo.check": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const ok = await this.runFunc(tabId, (selector) => {
-            const el = document.querySelector(selector);
-            if (!el) return false;
-            try {
-              el.scrollIntoView({ block: "center", behavior: "instant" });
-            } catch (e) {
-            }
-            if (!el.checked) el.click();
-            return true;
-          }, [params.selector]);
-          return { success: !!ok };
-        }
-        case "hanzo.uncheck": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const ok = await this.runFunc(tabId, (selector) => {
-            const el = document.querySelector(selector);
-            if (!el) return false;
-            try {
-              el.scrollIntoView({ block: "center", behavior: "instant" });
-            } catch (e) {
-            }
-            if (el.checked) el.click();
-            return true;
-          }, [params.selector]);
-          return { success: !!ok };
-        }
-        case "Input.dispatchKeyEvent": {
-          if (!tabId) throw new Error("No active tab");
-          const key = params.key || "";
-          const keyType = params.type || "keyDown";
-          await this.runInPage(tabId, `
-          var el = document.activeElement || document.body;
-          el.dispatchEvent(new KeyboardEvent('${keyType}', {key: '${this.escapeValue(key)}', bubbles: true}));
-          if ('${keyType}' === 'keyDown') {
-            el.dispatchEvent(new KeyboardEvent('keypress', {key: '${this.escapeValue(key)}', bubbles: true}));
-            el.dispatchEvent(new KeyboardEvent('keyup', {key: '${this.escapeValue(key)}', bubbles: true}));
-          }
-        `);
-          return { success: true };
-        }
-        // =====================================================================
-        // DOM Read
-        // =====================================================================
-        case "hanzo.getText": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const text = await this.runFunc(tabId, (selector) => {
-            const el = document.querySelector(selector);
-            return el ? el.textContent || "" : null;
-          }, [params.selector]);
-          return { result: { value: text } };
-        }
-        case "hanzo.getHTML": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const outer = params.outer !== false;
-          const html = await this.runFunc(tabId, (selector, useOuter) => {
-            const el = document.querySelector(selector);
-            if (!el) return null;
-            return useOuter ? el.outerHTML : el.innerHTML;
-          }, [params.selector, outer]);
-          return { result: { value: html } };
-        }
-        case "hanzo.getAttribute": {
-          if (!tabId || !params.selector || !params.attr) throw new Error("Missing params");
-          const sel = this.escapeSelector(params.selector);
-          const attr = this.escapeValue(params.attr);
-          const val = await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          return el ? el.getAttribute('${attr}') : null;
-        `);
-          return { result: { value: val } };
-        }
-        case "hanzo.getElementInfo": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          const info = await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (!el) return null;
-          var rect = el.getBoundingClientRect();
-          return {
-            tagName: el.tagName, id: el.id, className: el.className,
-            textContent: (el.textContent || '').trim().slice(0, 200),
-            value: el.value, type: el.type, href: el.href, src: el.src,
-            checked: el.checked, disabled: el.disabled,
-            visible: !!(rect.width && rect.height),
-            rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height }
-          };
-        `);
-          return { result: { value: info } };
-        }
-        case "hanzo.getPageInfo": {
-          if (!tabId) throw new Error("No active tab");
-          const pageInfo = await this.runInPage(tabId, `
-          return {
-            title: document.title,
-            url: location.href,
-            readyState: document.readyState,
-            contentType: document.contentType,
-            characterSet: document.characterSet,
-            documentElement: { scrollWidth: document.documentElement.scrollWidth, scrollHeight: document.documentElement.scrollHeight },
-            body: { scrollWidth: document.body?.scrollWidth, scrollHeight: document.body?.scrollHeight },
-            viewport: { width: window.innerWidth, height: window.innerHeight }
-          };
-        `);
-          return { result: { value: pageInfo } };
-        }
-        case "hanzo.querySelectorAll": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const elements = await this.runFunc(tabId, (selector, limit) => {
-            const els = document.querySelectorAll(selector);
-            const out = [];
-            const n = Math.min(els.length, limit);
-            for (let i = 0; i < n; i++) {
-              const el = els[i];
-              const rect = el.getBoundingClientRect();
-              out.push({
-                index: i,
-                tagName: el.tagName,
-                id: el.id || "",
-                className: typeof el.className === "string" ? el.className : "",
-                name: el.getAttribute("name") || "",
-                type: el.getAttribute("type") || "",
-                role: el.getAttribute("role") || "",
-                ariaLabel: el.getAttribute("aria-label") || "",
-                value: el.value || "",
-                href: el.href || "",
-                textContent: (el.textContent || "").trim().slice(0, 200),
-                visible: !!(rect.width && rect.height)
-              });
-            }
-            return out;
-          }, [params.selector, params.limit || 100]);
-          return { elements: elements || [] };
-        }
-        // ─────────────────────────────────────────────────────────────────
-        // CDP-shaped decomplected surface (1.9.16+). See dist/API.md for the
-        // canonical reference. Three orthogonal layers:
-        //   1) Wire transport (JSON over WS/HTTP)
-        //   2) CDP-shaped canonical primitives (Page.* DOM.* Input.* ...)
-        //   3) hanzo.* ergonomic aliases that compose canonical primitives
-        // Every DOM-touching method goes through runFunc → executeScript with
-        // a direct function reference. NEVER Function() / eval(). That is what
-        // makes them CSP-safe on .gov, github.com, and any strict-CSP SPA.
-        // ─────────────────────────────────────────────────────────────────
-        case "Input.dispatchMouseEvent": {
-          if (!tabId) throw new Error("No active tab");
-          const result = await this.runFunc(tabId, (p) => {
-            const { type, x, y, button = 0, clickCount = 1, modifiers = 0 } = p;
-            const target = document.elementFromPoint(x, y);
-            if (!target) return { delivered: false, reason: "no element at point" };
-            const mods = {
-              altKey: !!(modifiers & 1),
-              ctrlKey: !!(modifiers & 2),
-              metaKey: !!(modifiers & 4),
-              shiftKey: !!(modifiers & 8)
-            };
-            const init = {
-              bubbles: true,
-              cancelable: true,
-              view: window,
-              button,
-              buttons: type === "mousePressed" ? 1 : 0,
-              clientX: x,
-              clientY: y,
-              screenX: x,
-              screenY: y,
-              detail: clickCount,
-              ...mods
-            };
-            const map = { mouseMoved: "mousemove", mousePressed: "mousedown", mouseReleased: "mouseup" };
-            target.dispatchEvent(new MouseEvent(map[type] || type.toLowerCase(), init));
-            if (type === "mousePressed" && clickCount >= 1) {
-              target.dispatchEvent(new MouseEvent("click", init));
-            }
-            return { delivered: true, target: target.tagName, x, y };
-          }, [params]);
-          return result;
-        }
-        case "Input.scrollWheel": {
-          if (!tabId) throw new Error("No active tab");
-          const result = await this.runFunc(tabId, (p) => {
-            const { x = 0, y = 0, deltaX = 0, deltaY = 0 } = p;
-            const target = x || y ? document.elementFromPoint(x, y) : document.scrollingElement || document.body;
-            if (!target) return { delivered: false };
-            target.dispatchEvent(new WheelEvent("wheel", {
-              bubbles: true,
-              cancelable: true,
-              deltaX,
-              deltaY,
-              clientX: x,
-              clientY: y
-            }));
-            if (target === document.scrollingElement || target === document.body) {
-              window.scrollBy({ left: deltaX, top: deltaY, behavior: "instant" });
-            }
-            return { delivered: true };
-          }, [params]);
-          return result;
-        }
-        case "Page.printToPDF": {
-          if (!tabId) throw new Error("No active tab");
-          await this.runFunc(tabId, () => {
-            window.print();
-            return true;
-          }, []);
-          return {
-            opened: true,
-            note: "Firefox extension cannot programmatically save PDF. For headless PDF export use Page.captureScreenshot with fullPage=true and convert PNG\u2192PDF on the client side."
-          };
-        }
-        case "DOM.querySelector": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const element = await this.runFunc(tabId, (selector) => {
-            const el = document.querySelector(selector);
-            if (!el) return null;
-            const rect = el.getBoundingClientRect();
-            return {
-              tagName: el.tagName,
-              id: el.id || "",
-              className: typeof el.className === "string" ? el.className : "",
-              textContent: (el.textContent || "").trim().slice(0, 200),
-              value: el.value || "",
-              visible: !!(rect.width && rect.height),
-              rect: { x: rect.x, y: rect.y, w: rect.width, h: rect.height }
-            };
-          }, [params.selector]);
-          return { element };
-        }
-        case "DOM.scrollIntoView": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const ok = await this.runFunc(tabId, (selector) => {
-            const el = document.querySelector(selector);
-            if (!el) return false;
-            el.scrollIntoView({ block: "center", behavior: "smooth" });
-            return true;
-          }, [params.selector]);
-          return { success: !!ok };
-        }
-        case "DOM.focus": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const ok = await this.runFunc(tabId, (selector) => {
-            const el = document.querySelector(selector);
-            if (!el) return false;
-            el.focus();
-            return true;
-          }, [params.selector]);
-          return { success: !!ok };
-        }
-        case "hanzo.clickByText": {
-          if (!tabId || !params.text) throw new Error("No active tab or text");
-          const result = await this.runFunc(tabId, (text, scope) => {
-            const norm = (s) => (s || "").replace(/\s+/g, " ").trim().toLowerCase();
-            const want = norm(text);
-            const tags = scope === "all" ? "button, a, input[type=button], input[type=submit], input[type=radio], input[type=checkbox], label, [role=button], [role=radio], [role=checkbox], [role=tab], [role=menuitem]" : "button, a, label, [role=button], [role=radio], [role=checkbox], [role=tab], [role=menuitem]";
-            const els = Array.from(document.querySelectorAll(tags));
-            const matches = els.filter((el) => {
-              const t = norm(el.innerText || el.value || el.getAttribute("aria-label") || "");
-              return t === want || t.includes(want);
-            });
-            const exact = matches.find((el) => norm(el.innerText || el.value || el.getAttribute("aria-label") || "") === want) || matches[0];
-            if (!exact) return { clicked: false, candidates: matches.length };
-            try {
-              exact.scrollIntoView({ block: "center", behavior: "instant" });
-            } catch (e) {
-            }
-            exact.click();
-            return { clicked: true, tag: exact.tagName, text: (exact.innerText || exact.value || "").slice(0, 100) };
-          }, [params.text, params.scope || "default"]);
-          return result || { clicked: false };
-        }
-        case "hanzo.fillByLabel": {
-          if (!tabId || !params.label) throw new Error("No active tab or label");
-          const result = await this.runFunc(tabId, (labelText, value) => {
-            const norm = (s) => (s || "").replace(/\s+/g, " ").trim().toLowerCase();
-            const want = norm(labelText);
-            const labels = Array.from(document.querySelectorAll("label"));
-            const lbl = labels.find((l) => norm(l.innerText) === want) || labels.find((l) => norm(l.innerText).includes(want));
-            let input = null;
-            if (lbl) {
-              const forId = lbl.getAttribute("for");
-              if (forId) input = document.getElementById(forId);
-              if (!input) input = lbl.querySelector("input, textarea, select");
-            }
-            if (!input) {
-              const all = Array.from(document.querySelectorAll("input, textarea, select"));
-              input = all.find(
-                (el) => norm(el.getAttribute("aria-label") || "") === want || norm(el.getAttribute("placeholder") || "") === want || norm(el.getAttribute("name") || "") === want || norm(el.getAttribute("id") || "") === want
-              ) || null;
-            }
-            if (!input) return { filled: false };
-            try {
-              input.scrollIntoView({ block: "center", behavior: "instant" });
-            } catch (e) {
-            }
-            input.focus();
-            const tag = input.tagName;
-            if (tag === "INPUT" || tag === "TEXTAREA") {
-              const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, "value")?.set || Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, "value")?.set;
-              if (setter) setter.call(input, value);
-              else input.value = value;
-              input.dispatchEvent(new Event("input", { bubbles: true }));
-              input.dispatchEvent(new Event("change", { bubbles: true }));
-              return { filled: true, name: input.name || input.id };
-            }
-            if (tag === "SELECT") {
-              input.value = value;
-              input.dispatchEvent(new Event("change", { bubbles: true }));
-              return { filled: true, name: input.name || input.id };
-            }
-            return { filled: false };
-          }, [params.label, params.value || ""]);
-          return result || { filled: false };
-        }
-        case "hanzo.findByText": {
-          if (!tabId || !params.text) throw new Error("Missing text");
-          const result = await this.runFunc(tabId, (text, scope, limit) => {
-            const norm = (s) => (s || "").replace(/\s+/g, " ").trim().toLowerCase();
-            const want = norm(text);
-            const tagSel = scope === "all" ? "*" : "button, a, label, input, select, textarea, [role=button], [role=radio], [role=checkbox], [role=tab], [role=menuitem], h1, h2, h3, h4, h5, h6, p, span, li, td";
-            const els = Array.from(document.querySelectorAll(tagSel));
-            const matches = [];
-            for (let i = 0; i < els.length && matches.length < limit; i++) {
-              const el = els[i];
-              const t = norm(el.innerText || el.value || el.getAttribute("aria-label") || "");
-              if (!t) continue;
-              if (t === want || t.includes(want)) {
-                const rect = el.getBoundingClientRect();
-                matches.push({
-                  index: i,
-                  tag: el.tagName,
-                  id: el.id || "",
-                  className: typeof el.className === "string" ? el.className : "",
-                  text: t.slice(0, 200),
-                  exact: t === want,
-                  rect: { x: rect.x, y: rect.y, w: rect.width, h: rect.height },
-                  visible: !!(rect.width && rect.height)
-                });
-              }
-            }
-            matches.sort((a, b) => (b.exact ? 1 : 0) - (a.exact ? 1 : 0));
-            return matches;
-          }, [params.text, params.scope || "default", params.limit || 50]);
-          return { matches: result || [] };
-        }
-        case "hanzo.listForm": {
-          if (!tabId) throw new Error("No active tab");
-          const inputs = await this.runFunc(tabId, () => {
-            const all = Array.from(document.querySelectorAll("input, textarea, select, button, label, [role=radio], [role=checkbox], [role=button]"));
-            return all.slice(0, 200).map((el, i) => {
-              const rect = el.getBoundingClientRect();
-              const lblFor = el.id ? document.querySelector(`label[for="${el.id}"]`) : null;
-              return {
-                i,
-                tag: el.tagName,
-                type: el.getAttribute("type") || "",
-                name: el.getAttribute("name") || "",
-                id: el.id || "",
-                role: el.getAttribute("role") || "",
-                ariaLabel: el.getAttribute("aria-label") || "",
-                placeholder: el.getAttribute("placeholder") || "",
-                value: el.value || "",
-                checked: !!el.checked,
-                labelText: (lblFor?.innerText || "").trim().slice(0, 200),
-                innerText: (el.innerText || "").trim().slice(0, 200),
-                visible: !!(rect.width && rect.height)
-              };
-            });
-          }, []);
-          return { inputs: inputs || [] };
-        }
-        case "hanzo.press": {
-          if (!tabId || !params.key) throw new Error("Missing key");
-          const result = await this.runFunc(tabId, (key, modifiers) => {
-            const el = document.activeElement || document.body;
-            const mods = {
-              altKey: !!modifiers?.alt,
-              ctrlKey: !!modifiers?.ctrl,
-              metaKey: !!modifiers?.meta,
-              shiftKey: !!modifiers?.shift
-            };
-            const keyCodeMap = {
-              Enter: 13,
-              Tab: 9,
-              Escape: 27,
-              Backspace: 8,
-              Delete: 46,
-              ArrowUp: 38,
-              ArrowDown: 40,
-              ArrowLeft: 37,
-              ArrowRight: 39,
-              Home: 36,
-              End: 35,
-              PageUp: 33,
-              PageDown: 34,
-              " ": 32
-            };
-            const keyCode = keyCodeMap[key] ?? (key.length === 1 ? key.toUpperCase().charCodeAt(0) : 0);
-            const init = { key, code: key, keyCode, which: keyCode, bubbles: true, cancelable: true, ...mods };
-            el.dispatchEvent(new KeyboardEvent("keydown", init));
-            if (key.length === 1) el.dispatchEvent(new KeyboardEvent("keypress", init));
-            el.dispatchEvent(new KeyboardEvent("keyup", init));
-            if (key === "Enter" && el.tagName === "INPUT") {
-              const form = el.form;
-              if (form) {
-                try {
-                  form.requestSubmit?.() || form.submit?.();
-                } catch (e) {
-                }
-              }
-            }
-            return { delivered: true, target: el.tagName, keyCode };
-          }, [params.key, params.modifiers || {}]);
-          return result;
-        }
-        case "hanzo.scroll": {
-          if (!tabId) throw new Error("No active tab");
-          const result = await this.runFunc(tabId, (target, amount) => {
-            if (target === "top") {
-              window.scrollTo({ top: 0, behavior: "smooth" });
-              return { scrolled: "top" };
-            }
-            if (target === "bottom") {
-              window.scrollTo({ top: document.body?.scrollHeight || 0, behavior: "smooth" });
-              return { scrolled: "bottom" };
-            }
-            if (typeof target === "string" && target) {
-              const el = document.querySelector(target);
-              if (el) {
-                el.scrollIntoView({ behavior: "smooth", block: "center" });
-                return { scrolled: "into-view", selector: target };
-              }
-              return { scrolled: null, error: "selector not found", selector: target };
-            }
-            if (amount && (amount.x || amount.y)) {
-              window.scrollBy({ left: amount.x || 0, top: amount.y || 0, behavior: "smooth" });
-              return { scrolled: "by", ...amount };
-            }
-            return { scrolled: null, error: "no target or amount" };
-          }, [params.target || params.selector || null, params.amount || null]);
-          return result;
-        }
-        case "hanzo.waitForText": {
-          if (!tabId || !params.text) throw new Error("Missing text");
-          const timeoutMs = params.timeout || 15e3;
-          const interval = params.interval || 250;
-          const start = Date.now();
-          while (Date.now() - start < timeoutMs) {
-            const found = await this.runFunc(tabId, (text) => {
-              const norm = (s) => (s || "").replace(/\s+/g, " ").trim().toLowerCase();
-              return norm(document.body?.innerText || "").includes(norm(text));
-            }, [params.text]);
-            if (found) return { found: true, elapsed: Date.now() - start };
-            await new Promise((r) => setTimeout(r, interval));
-          }
-          return { found: false, timedOut: true, elapsed: Date.now() - start };
-        }
-        case "hanzo.waitForMutation": {
-          if (!tabId || !params.selector) throw new Error("Missing selector");
-          const timeoutMs = params.timeout || 15e3;
-          const result = await this.runFunc(tabId, (selector, timeout) => {
-            return new Promise((resolve) => {
-              const existing = document.querySelector(selector);
-              if (existing) {
-                resolve({ found: true, immediate: true });
-                return;
-              }
-              const observer = new MutationObserver(() => {
-                const el = document.querySelector(selector);
-                if (el) {
-                  observer.disconnect();
-                  resolve({ found: true, immediate: false });
-                }
-              });
-              observer.observe(document.documentElement, { childList: true, subtree: true, attributes: true });
-              setTimeout(() => {
-                observer.disconnect();
-                resolve({ found: false, timedOut: true });
-              }, timeout);
-            });
-          }, [params.selector, timeoutMs]);
-          return result;
-        }
-        case "hanzo.submitForm": {
-          if (!tabId) throw new Error("No active tab");
-          const result = await this.runFunc(tabId, (hint) => {
-            const norm = (s) => (s || "").replace(/\s+/g, " ").trim().toLowerCase();
-            const intents = hint ? [hint] : ["submit", "continue", "next", "save", "send", "agree", "accept", "ok"];
-            const wantList = intents.map(norm);
-            const candidates = Array.from(document.querySelectorAll(
-              "button, input[type=submit], input[type=button], a[role=button], [role=button], a.btn"
-            ));
-            for (const want of wantList) {
-              for (const c of candidates) {
-                const t = norm(c.innerText || c.value || c.getAttribute("aria-label") || "");
-                if (t === want) {
-                  try {
-                    c.scrollIntoView({ block: "center" });
-                  } catch (e) {
-                  }
-                  c.click();
-                  return { submitted: true, intent: want, tag: c.tagName, text: t.slice(0, 100), exact: true };
-                }
-              }
-              for (const c of candidates) {
-                const t = norm(c.innerText || c.value || c.getAttribute("aria-label") || "");
-                if (t.includes(want)) {
-                  try {
-                    c.scrollIntoView({ block: "center" });
-                  } catch (e) {
-                  }
-                  c.click();
-                  return { submitted: true, intent: want, tag: c.tagName, text: t.slice(0, 100), exact: false };
-                }
-              }
-            }
-            return { submitted: false, candidates: candidates.length, intents };
-          }, [params.intent || null]);
-          return result;
-        }
-        case "hanzo.uploadFile": {
-          if (!tabId || !params.selector || !params.content || !params.name) {
-            throw new Error("Need selector, name, content (base64)");
-          }
-          const result = await this.runFunc(tabId, (selector, name, mimeType, contentB64) => {
-            const el = document.querySelector(selector);
-            if (!el) return { uploaded: false, error: "selector not found" };
-            if (el.tagName !== "INPUT" || el.type !== "file") return { uploaded: false, error: "not a file input" };
-            const binStr = atob(contentB64);
-            const bytes = new Uint8Array(binStr.length);
-            for (let i = 0; i < binStr.length; i++) bytes[i] = binStr.charCodeAt(i);
-            const file = new File([bytes], name, { type: mimeType });
-            const dt = new DataTransfer();
-            dt.items.add(file);
-            el.files = dt.files;
-            el.dispatchEvent(new Event("input", { bubbles: true }));
-            el.dispatchEvent(new Event("change", { bubbles: true }));
-            return { uploaded: true, name, size: bytes.byteLength };
-          }, [params.selector, params.name, params.mimeType || "application/octet-stream", params.content]);
-          return result;
-        }
-        case "hanzo.dialogAccept": {
-          if (!tabId) throw new Error("No active tab");
-          await this.runFunc(tabId, (acceptText) => {
-            const W = window;
-            W.__hanzo_dialogText = acceptText || "";
-            W.alert = () => true;
-            W.confirm = () => true;
-            W.prompt = () => W.__hanzo_dialogText || "";
-            return true;
-          }, [params.text || ""]);
-          return { armed: true };
-        }
-        case "hanzo.observe": {
-          if (!tabId || !params.name) throw new Error("Missing name");
-          await this.runFunc(tabId, (name, selector, opts) => {
-            const W = window;
-            W.__hanzo_obs = W.__hanzo_obs || {};
-            if (W.__hanzo_obs[name]?.observer) W.__hanzo_obs[name].observer.disconnect();
-            W.__hanzo_obs[name] = { events: [], observer: null };
-            const target = selector ? document.querySelector(selector) : document.documentElement;
-            if (!target) return false;
-            const obs = new MutationObserver((mutations) => {
-              for (const m of mutations) {
-                W.__hanzo_obs[name].events.push({
-                  type: m.type,
-                  target: m.target?.tagName || "",
-                  added: m.addedNodes?.length || 0,
-                  removed: m.removedNodes?.length || 0,
-                  attr: m.attributeName || null,
-                  ts: Date.now()
-                });
-                if (W.__hanzo_obs[name].events.length > 500) W.__hanzo_obs[name].events.shift();
-              }
-            });
-            obs.observe(target, opts || { childList: true, subtree: true, attributes: true });
-            W.__hanzo_obs[name].observer = obs;
-            return true;
-          }, [params.name, params.selector || null, params.options || null]);
-          return { started: true, name: params.name };
-        }
-        case "hanzo.observeRead": {
-          if (!tabId || !params.name) throw new Error("Missing name");
-          const events = await this.runFunc(tabId, (name, clear) => {
-            const W = window;
-            const entry = W.__hanzo_obs?.[name];
-            if (!entry) return [];
-            const out = entry.events.slice();
-            if (clear !== false) entry.events.length = 0;
-            return out;
-          }, [params.name, params.clear !== false]);
-          return { events: events || [] };
-        }
-        case "hanzo.observeStop": {
-          if (!tabId || !params.name) throw new Error("Missing name");
-          await this.runFunc(tabId, (name) => {
-            const W = window;
-            const entry = W.__hanzo_obs?.[name];
-            if (entry?.observer) entry.observer.disconnect();
-            if (W.__hanzo_obs) delete W.__hanzo_obs[name];
-            return true;
-          }, [params.name]);
-          return { stopped: true, name: params.name };
-        }
-        case "hanzo.getComputedStyles": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          const props = params.properties || ["display", "visibility", "opacity", "position", "color", "backgroundColor", "fontSize"];
-          const propsStr = JSON.stringify(props);
-          const styles = await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (!el) return null;
-          var cs = window.getComputedStyle(el);
-          var props = ${propsStr};
-          var result = {};
-          props.forEach(function(p) { result[p] = cs.getPropertyValue(p) || cs[p]; });
-          return result;
-        `);
-          return { result: { value: styles } };
-        }
-        case "hanzo.getBoundingRects": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          const rects = await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (!el) return null;
-          var r = el.getBoundingClientRect();
-          return { x: r.x, y: r.y, width: r.width, height: r.height, top: r.top, right: r.right, bottom: r.bottom, left: r.left };
-        `);
-          return { result: { value: rects } };
-        }
-        // =====================================================================
-        // DOM Write
-        // =====================================================================
-        case "hanzo.setText": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          const txt = this.escapeValue(params.text || "");
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) el.textContent = '${txt}';
-        `);
-          return { success: true };
-        }
-        case "hanzo.setHTML": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          const html = this.escapeValue(params.html || "");
-          const outer = params.outer === true;
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) ${outer ? `el.outerHTML = '${html}'` : `el.innerHTML = '${html}'`};
-        `);
-          return { success: true };
-        }
-        case "hanzo.setAttribute": {
-          if (!tabId || !params.selector || !params.attr) throw new Error("Missing params");
-          const sel = this.escapeSelector(params.selector);
-          const attr = this.escapeValue(params.attr);
-          const val = this.escapeValue(params.value || "");
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) el.setAttribute('${attr}', '${val}');
-        `);
-          return { success: true };
-        }
-        case "hanzo.removeAttribute": {
-          if (!tabId || !params.selector || !params.attr) throw new Error("Missing params");
-          const sel = this.escapeSelector(params.selector);
-          const attr = this.escapeValue(params.attr);
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) el.removeAttribute('${attr}');
-        `);
-          return { success: true };
-        }
-        case "hanzo.setStyle": {
-          if (!tabId || !params.selector || !params.styles) throw new Error("Missing params");
-          const sel = this.escapeSelector(params.selector);
-          const stylesJson = JSON.stringify(params.styles);
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) {
-            var styles = ${stylesJson};
-            for (var k in styles) { if (styles.hasOwnProperty(k)) el.style[k] = styles[k]; }
-          }
-        `);
-          return { success: true };
-        }
-        case "hanzo.addClass": {
-          if (!tabId || !params.selector || !params.classNames) throw new Error("Missing params");
-          const sel = this.escapeSelector(params.selector);
-          const classes = Array.isArray(params.classNames) ? params.classNames : [params.classNames];
-          const classesJson = JSON.stringify(classes);
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) el.classList.add.apply(el.classList, ${classesJson});
-        `);
-          return { success: true };
-        }
-        case "hanzo.removeClass": {
-          if (!tabId || !params.selector || !params.classNames) throw new Error("Missing params");
-          const sel = this.escapeSelector(params.selector);
-          const classes = Array.isArray(params.classNames) ? params.classNames : [params.classNames];
-          const classesJson = JSON.stringify(classes);
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) el.classList.remove.apply(el.classList, ${classesJson});
-        `);
-          return { success: true };
-        }
-        case "hanzo.insertElement": {
-          if (!tabId || !params.selector || !params.html) throw new Error("Missing params");
-          const sel = this.escapeSelector(params.selector);
-          const html = this.escapeValue(params.html);
-          const position = params.position || "beforeend";
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) el.insertAdjacentHTML('${position}', '${html}');
-        `);
-          return { success: true };
-        }
-        case "hanzo.removeElement": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          await this.runInPage(tabId, `
-          var el = document.querySelector('${sel}');
-          if (el) el.remove();
-        `);
-          return { success: true };
-        }
-        // =====================================================================
-        // DOM Observation
-        // =====================================================================
-        case "hanzo.observeMutations": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          const duration = params.duration || 3e3;
-          const mutations = await this.runInPage(tabId, `
-          return new Promise(function(resolve) {
-            var el = document.querySelector('${sel}') || document.body;
-            var records = [];
-            var obs = new MutationObserver(function(muts) {
-              muts.forEach(function(m) {
-                records.push({
-                  type: m.type,
-                  target: m.target.tagName + (m.target.id ? '#' + m.target.id : ''),
-                  addedNodes: m.addedNodes.length,
-                  removedNodes: m.removedNodes.length,
-                  attributeName: m.attributeName
-                });
-              });
-            });
-            obs.observe(el, { childList: true, attributes: true, subtree: true, characterData: true });
-            setTimeout(function() { obs.disconnect(); resolve(records.slice(0, 50)); }, ${Math.min(duration, 1e4)});
-          });
-        `, duration + 2e3);
-          return { mutations: mutations || [] };
-        }
-        // =====================================================================
-        // Wait for selector
-        // =====================================================================
-        case "hanzo.waitForSelector": {
-          if (!tabId || !params.selector) throw new Error("No active tab or selector");
-          const sel = this.escapeSelector(params.selector);
-          const waitTimeout = params.timeout || 1e4;
-          const found = await this.runInPage(tabId, `
-          return new Promise(function(resolve) {
-            var el = document.querySelector('${sel}');
-            if (el) { resolve(true); return; }
-            var obs = new MutationObserver(function() {
-              var el = document.querySelector('${sel}');
-              if (el) { obs.disconnect(); resolve(true); }
-            });
-            obs.observe(document.body, { childList: true, subtree: true });
-            setTimeout(function() { obs.disconnect(); resolve(false); }, ${Math.min(waitTimeout, 3e4)});
-          });
-        `, waitTimeout + 2e3);
-          return { found: !!found };
-        }
-        // =====================================================================
-        // Inject script / CSS
-        // =====================================================================
-        case "hanzo.injectScript": {
-          if (!tabId || !params.url) throw new Error("No active tab or url");
-          const scriptUrl = this.escapeValue(params.url);
-          await this.runInPage(tabId, `
-          return new Promise(function(resolve) {
-            var s = document.createElement('script');
-            s.src = '${scriptUrl}';
-            s.onload = function() { resolve(true); };
-            s.onerror = function() { resolve(false); };
-            document.head.appendChild(s);
-          });
-        `, 15e3);
-          return { success: true };
-        }
-        case "hanzo.injectCSS": {
-          if (!tabId || !params.css) throw new Error("No active tab or css");
-          const css = this.escapeValue(params.css);
-          await this.runInPage(tabId, `
-          var style = document.createElement('style');
-          style.textContent = '${css}';
-          document.head.appendChild(style);
-        `);
-          return { success: true };
-        }
-        // =====================================================================
-        // Storage / Cookies
-        // =====================================================================
-        case "hanzo.getLocalStorage": {
-          if (!tabId) throw new Error("No active tab");
-          const key = params.key ? this.escapeValue(params.key) : null;
-          const storageVal = await this.runInPage(
-            tabId,
-            key ? `return localStorage.getItem('${key}');` : `
-            var result = {};
-            for (var i = 0; i < localStorage.length; i++) {
-              var k = localStorage.key(i);
-              result[k] = localStorage.getItem(k);
-            }
-            return result;
-          `
-          );
-          return { result: { value: storageVal } };
-        }
-        case "hanzo.setLocalStorage": {
-          if (!tabId || !params.key) throw new Error("No active tab or key");
-          const key = this.escapeValue(params.key);
-          const val = this.escapeValue(params.value || "");
-          await this.runInPage(tabId, `localStorage.setItem('${key}', '${val}');`);
-          return { success: true };
-        }
-        case "hanzo.getCookies": {
-          try {
-            const url = tab?.url || "";
-            const cookies = await browser.cookies.getAll({ url });
-            return { cookies: cookies.map((c) => ({ name: c.name, value: c.value, domain: c.domain, path: c.path, secure: c.secure, httpOnly: c.httpOnly })) };
-          } catch {
-            return { cookies: [], error: "cookies API not available" };
-          }
-        }
-        // =====================================================================
-        // Fetch through page context (uses page cookies/auth)
-        // =====================================================================
-        case "hanzo.fetch": {
-          if (!tabId || !params.url) throw new Error("No active tab or url");
-          const fetchUrl = this.escapeValue(params.url);
-          const fetchOpts = params.options || {};
-          const optsJson = JSON.stringify(fetchOpts);
-          const fetchResult = await this.runInPage(tabId, `
-          return fetch('${fetchUrl}', ${optsJson}).then(function(r) {
-            return r.text().then(function(body) {
-              return { status: r.status, statusText: r.statusText, ok: r.ok, body: body.slice(0, 50000) };
-            });
-          });
-        `, 3e4);
-          return fetchResult || { error: "fetch failed" };
-        }
-        // =====================================================================
-        // Control session
-        // =====================================================================
-        case "hanzo.control.start": {
-          const targetTabId = await this.resolveControlTabId(params.tabId);
-          if (targetTabId) {
-            await this.startControlSession(targetTabId, params.task);
-            return { success: true };
-          }
-          throw new Error("No active tab");
-        }
-        case "hanzo.control.stop": {
-          await this.stopControlSession();
-          return { success: true };
-        }
-        // =====================================================================
-        // Browser info
-        // =====================================================================
-        case "Browser.getVersion": {
-          return {
-            protocolVersion: "1.3",
-            product: "Hanzo Firefox Extension",
-            userAgent: navigator.userAgent
-          };
-        }
-        default:
-          console.warn("[Hanzo] Unknown method:", method);
-          return { error: `Unknown method: ${method}` };
-      }
-    }
-    /**
-     * Handle extension-request messages (monitor, audit, ollama, hub, etc.)
-     * These are routed via sendToExtension() from the CDP bridge.
-     */
-    async handleExtensionRequest(action, params) {
-      const tabId = params.tabId || await this.getActiveTabId() || void 0;
-      if (action.startsWith("monitor.")) {
-        if (!tabId) return { error: "No active tab for monitoring" };
-        switch (action) {
-          case "monitor.consoleLogs":
-            return this.runInPage(tabId, `
-            return (window.__hanzo_console_logs || []).slice(-50);
-          `).then((logs) => ({ logs: logs || [] })).catch(() => ({ logs: [] }));
-          case "monitor.consoleErrors":
-            return this.runInPage(tabId, `
-            return (window.__hanzo_console_errors || []).slice(-50);
-          `).then((errors) => ({ errors: errors || [] })).catch(() => ({ errors: [] }));
-          case "monitor.networkLogs":
-          case "monitor.networkErrors":
-          case "monitor.networkSuccess":
-            return { logs: [], note: "Network monitoring requires devtools API (not available in MV3 extensions)" };
-          case "monitor.wipeLogs":
-            return this.runInPage(tabId, `
-            window.__hanzo_console_logs = [];
-            window.__hanzo_console_errors = [];
-          `).then(() => ({ success: true })).catch(() => ({ success: false }));
-          case "monitor.start":
-            return this.runInPage(tabId, `
-            if (!window.__hanzo_monitor_active) {
-              window.__hanzo_console_logs = [];
-              window.__hanzo_console_errors = [];
-              var origLog = console.log, origErr = console.error, origWarn = console.warn;
-              console.log = function() { window.__hanzo_console_logs.push({type:'log', args: Array.from(arguments).map(String), ts: Date.now()}); origLog.apply(console, arguments); };
-              console.error = function() { window.__hanzo_console_errors.push({type:'error', args: Array.from(arguments).map(String), ts: Date.now()}); origErr.apply(console, arguments); };
-              console.warn = function() { window.__hanzo_console_logs.push({type:'warn', args: Array.from(arguments).map(String), ts: Date.now()}); origWarn.apply(console, arguments); };
-              window.__hanzo_monitor_active = true;
-            }
-          `).then(() => ({ success: true })).catch(() => ({ success: false }));
-          case "monitor.stop":
-            return { success: true };
-          case "monitor.status":
-            return { active: false };
-          default:
-            return { error: `Unknown monitor action: ${action}` };
-        }
-      }
-      if (action.startsWith("audit.")) {
-        if (!tabId) return { error: "No active tab for audit" };
-        switch (action) {
-          case "audit.accessibility":
-            return this.runInPage(tabId, `
-            var issues = [];
-            document.querySelectorAll('img').forEach(function(img) { if (!img.alt) issues.push({type:'missing-alt', el:img.tagName, src:img.src?.slice(0,80)}); });
-            document.querySelectorAll('a').forEach(function(a) { if (!a.textContent?.trim() && !a.getAttribute('aria-label')) issues.push({type:'empty-link', href:a.href?.slice(0,80)}); });
-            document.querySelectorAll('input,textarea,select').forEach(function(el) {
-              if (!el.getAttribute('aria-label') && !el.labels?.length && !el.placeholder) issues.push({type:'unlabeled-input', name:el.name, id:el.id});
-            });
-            return { issues: issues.slice(0, 50), total: issues.length };
-          `).then((r) => ({ audit: r })).catch((e) => ({ error: e.message }));
-          case "audit.performance":
-            return this.runInPage(tabId, `
-            var p = performance;
-            var nav = p.getEntriesByType('navigation')[0] || {};
-            return {
-              domContentLoaded: nav.domContentLoadedEventEnd,
-              load: nav.loadEventEnd,
-              resources: p.getEntriesByType('resource').length,
-              domNodes: document.querySelectorAll('*').length
-            };
-          `).then((r) => ({ audit: r })).catch((e) => ({ error: e.message }));
-          case "audit.seo":
-            return this.runInPage(tabId, `
-            return {
-              title: document.title,
-              metaDescription: document.querySelector('meta[name="description"]')?.content || null,
-              h1Count: document.querySelectorAll('h1').length,
-              canonical: document.querySelector('link[rel="canonical"]')?.href || null,
-              ogTitle: document.querySelector('meta[property="og:title"]')?.content || null,
-              ogDescription: document.querySelector('meta[property="og:description"]')?.content || null
-            };
-          `).then((r) => ({ audit: r })).catch((e) => ({ error: e.message }));
-          default:
-            return { error: `Audit type not implemented: ${action}` };
-        }
-      }
-      if (action === "debugger.mode") {
-        return { error: "Debugger mode requires devtools API (not available in MV3)" };
-      }
-      if (action.startsWith("ollama.") || action.startsWith("local.") || action.startsWith("hub.")) {
-        return { error: `${action} not yet implemented in Firefox extension` };
-      }
-      try {
-        return await this.executeMethod(action, params || {});
-      } catch (e) {
-        return { error: e && e.message || String(e) };
-      }
-    }
-    notifyOverlay(tabId, action, data) {
-      browser.tabs.sendMessage(tabId, { action, ...data }).catch(() => {
-      });
-    }
-    async getActiveTabId() {
-      const [tab] = await browser.tabs.query({ active: true, currentWindow: true });
-      return tab?.id ?? null;
-    }
-    async resolveControlTabId(tabId) {
-      if (typeof tabId === "number") return tabId;
-      if (controlSession.active && controlSession.tabId !== null) return controlSession.tabId;
-      return this.getActiveTabId();
-    }
-    async startControlSession(tabId, task) {
-      if (controlSession.active && controlSession.tabId !== null && controlSession.tabId !== tabId) {
-        this.notifyOverlay(controlSession.tabId, "ai.control.stop", {});
-      }
-      controlSession.active = true;
-      controlSession.tabId = tabId;
-      controlSession.task = task || "AI is controlling this page";
-      controlSession.startedAt = Date.now();
-      this.notifyOverlay(tabId, "ai.control.start", { task: controlSession.task });
-    }
-    async stopControlSession() {
-      if (controlSession.active && controlSession.tabId !== null) {
-        this.notifyOverlay(controlSession.tabId, "ai.control.stop", {});
-      }
-      controlSession.active = false;
-      controlSession.tabId = null;
-      controlSession.task = null;
-      controlSession.startedAt = null;
-    }
-    escapeSelector(selector) {
-      return selector.replace(/'/g, "\\'");
-    }
-    escapeValue(value) {
-      return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n");
-    }
-    isBridgeConnected() {
-      return this.wsConnection !== null && this.wsConnection.readyState === WebSocket.OPEN;
-    }
-  };
-  var IAM_V1 = `${IAM_API_URL}${IAM_API_PATH}`;
-  var ffAdapter = firefoxAdapter();
-  async function getValidAccessToken2() {
-    return getValidAccessToken(ffAdapter.storage);
-  }
-  browser.runtime.onMessage.addListener((request, sender, sendResponse) => {
-    (async () => {
-      if (typeof request.action === "string" && request.action.startsWith("zap.")) {
-        if (handleZapMessage(request.action, request, sendResponse, zapMgr, BROWSER_NAME, VERSION)) {
-          return;
-        }
-      }
-      switch (request.action) {
-        // =======================================================================
-        // Auth (Hanzo IAM OAuth2 + PKCE)
-        // =======================================================================
-        case "auth.login":
-          try {
-            const user = await login(ffAdapter);
-            sendResponse({ success: true, user });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        case "auth.signup":
-          try {
-            await signup(ffAdapter);
-            sendResponse({ success: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        case "auth.logout":
-          await logout(ffAdapter.storage);
-          sendResponse({ success: true });
-          break;
-        case "auth.status": {
-          const status = await getAuthStatus(ffAdapter.storage);
-          sendResponse({
-            success: true,
-            authenticated: status.authenticated,
-            user: status.user
-          });
-          break;
-        }
-        case "auth.getToken": {
-          const r = await browser.storage.local.get([STORAGE_KEYS.accessToken]);
-          sendResponse({ success: !!r[STORAGE_KEYS.accessToken], token: r[STORAGE_KEYS.accessToken] || null });
-          break;
-        }
-        // =======================================================================
-        // RAG (uses shared module — now with ZAP memory support)
-        // =======================================================================
-        case "rag.query": {
-          try {
-            const config = await getRagConfig(browser.storage.local);
-            const topKInput = Number.parseInt(String(request.topK ?? config.topK), 10);
-            const params = {
-              query: String(request.query || "").trim(),
-              topK: Number.isFinite(topKInput) ? Math.max(1, Math.min(topKInput, 20)) : 5,
-              knowledgeBase: String(request.knowledgeBase ?? config.knowledgeBase ?? "").trim(),
-              includeTabContext: request.includeTabContext !== void 0 ? !!request.includeTabContext : config.includeTabContext,
-              useZapMemory: request.useZapMemory !== void 0 ? !!request.useZapMemory : config.useZapMemory,
-              endpoint: String(request.endpoint ?? config.endpoint ?? "").trim(),
-              apiKey: String(request.apiKey ?? config.apiKey ?? "").trim(),
-              mcpId: request.mcpId ? String(request.mcpId) : void 0,
-              pageContext: request.pageContext && typeof request.pageContext === "object" ? {
-                url: request.pageContext.url ? String(request.pageContext.url) : void 0,
-                title: request.pageContext.title ? String(request.pageContext.title) : void 0
-              } : void 0
-            };
-            if (!params.query) {
-              sendResponse({ success: false, error: "Query is required" });
-              break;
-            }
-            let snippets = await queryRagFromZap(params, zapMgr);
-            let source = snippets.length ? "zap-memory" : "none";
-            if (!snippets.length && params.endpoint) {
-              snippets = await queryRagFromEndpoint(params);
-              source = snippets.length ? "rag-endpoint" : source;
-            }
-            sendResponse({
-              success: true,
-              source,
-              snippets: snippets.slice(0, params.topK)
-            });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // =======================================================================
-        // Cloud Chat
-        // =======================================================================
-        case "chat.listModels": {
-          try {
-            const token = await getValidAccessToken2();
-            if (!token) {
-              sendResponse({ success: false, error: "Not authenticated" });
-              break;
-            }
-            const resp = await fetch(`${API_BASE_URL}/v1/models`, {
-              headers: { Authorization: `Bearer ${token}` },
-              signal: AbortSignal.timeout(1e4)
-            });
-            const data = await resp.json();
-            sendResponse({ success: true, models: data.data || data.models || data || [] });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "chat.complete": {
-          try {
-            const token = await getValidAccessToken2();
-            if (!token) {
-              sendResponse({ success: false, error: "Not authenticated" });
-              break;
-            }
-            const messages = (Array.isArray(request.messages) ? request.messages : []).filter((m) => m && typeof m.content === "string" && typeof m.role === "string").map((m) => ({
-              role: m.role === "system" || m.role === "assistant" ? m.role : "user",
-              content: String(m.content)
-            }));
-            if (!messages.length) {
-              sendResponse({ success: false, error: "messages are required" });
-              break;
-            }
-            const model = String(request.model || "auto");
-            const body = { model, messages, stream: false };
-            if (typeof request.temperature === "number") body.temperature = request.temperature;
-            if (typeof request.max_tokens === "number") body.max_tokens = Math.max(64, Math.min(request.max_tokens, 16384));
-            const resp = await fetch(`${API_BASE_URL}/v1/chat/completions`, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${token}`
-              },
-              body: JSON.stringify(body),
-              signal: AbortSignal.timeout(12e4)
-            });
-            if (!resp.ok) {
-              const text = await resp.text();
-              throw new Error(`Chat API error ${resp.status}: ${text}`);
-            }
-            const data = await resp.json();
-            const content = data.choices?.[0]?.message?.content || "";
-            sendResponse({ success: true, content, model: data.model || model });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "chat.cancel":
-          sendResponse({ success: true });
-          break;
-        // =======================================================================
-        // Models
-        // =======================================================================
-        case "models.list": {
-          try {
-            const token = await getValidAccessToken2();
-            if (!token) {
-              try {
-                const pubResp = await fetch(`${API_BASE_URL}/v1/models`, { signal: AbortSignal.timeout(5e3) });
-                const pubData = await pubResp.json();
-                sendResponse({ success: true, models: pubData.data || [], authenticated: false });
-              } catch {
-                sendResponse({ success: true, models: [], authenticated: false });
-              }
-              break;
-            }
-            const resp = await fetch(`${API_BASE_URL}/v1/models`, {
-              headers: { Authorization: `Bearer ${token}` },
-              signal: AbortSignal.timeout(1e4)
-            });
-            const data = await resp.json();
-            sendResponse({ success: true, models: data.data || data.models || [], authenticated: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // =======================================================================
-        // WebGPU / Local AI
-        // =======================================================================
-        case "checkWebGPU": {
-          try {
-            if (typeof navigator === "undefined" || !navigator.gpu) {
-              sendResponse({ available: false });
-              break;
-            }
-            const adapter = await navigator.gpu.requestAdapter();
-            sendResponse({
-              available: !!adapter,
-              adapter: adapter?.name || "Unknown GPU",
-              models: []
-            });
-          } catch {
-            sendResponse({ available: false });
-          }
-          break;
-        }
-        case "runLocalAI":
-          sendResponse({ success: false, error: "WebGPU inference not available in Firefox background" });
-          break;
-        case "listAgents":
-          sendResponse({ success: true, agents: [] });
-          break;
-        case "stopAgent":
-          sendResponse({ success: false, error: "Agent workers are not available in Firefox background mode" });
-          break;
-        case "launchAIWorker":
-          sendResponse({ success: false, error: "launchAIWorker not implemented in Firefox background mode" });
-          break;
-        // =======================================================================
-        // Ollama / Local LLM (portable — pure HTTP)
-        // =======================================================================
-        case "ollama.discover": {
-          try {
-            const urls = ["http://localhost:11434", "http://127.0.0.1:11434"];
-            let found = false;
-            let ollamaUrl = "";
-            for (const u of urls) {
-              try {
-                const resp = await fetch(u, { signal: AbortSignal.timeout(2e3) });
-                if (resp.ok) {
-                  found = true;
-                  ollamaUrl = u;
-                  break;
-                }
-              } catch {
-              }
-            }
-            sendResponse({ success: true, discovered: found, url: ollamaUrl, available: found });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "ollama.health": {
-          try {
-            const stored = await browser.storage.local.get(["ollamaUrl"]);
-            const url = stored.ollamaUrl || "http://localhost:11434";
-            const resp = await fetch(url, { signal: AbortSignal.timeout(3e3) });
-            sendResponse({ success: true, available: resp.ok, url });
-          } catch (e) {
-            sendResponse({ success: false, available: false, error: e.message });
-          }
-          break;
-        }
-        case "ollama.models": {
-          try {
-            const stored = await browser.storage.local.get(["ollamaUrl"]);
-            const url = stored.ollamaUrl || "http://localhost:11434";
-            const resp = await fetch(`${url}/api/tags`, { signal: AbortSignal.timeout(5e3) });
-            if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-            const data = await resp.json();
-            sendResponse({ success: true, models: data.models || [] });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "ollama.chat": {
-          try {
-            const stored = await browser.storage.local.get(["ollamaUrl"]);
-            const url = stored.ollamaUrl || "http://localhost:11434";
-            const resp = await fetch(`${url}/api/chat`, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({
-                model: request.model,
-                messages: request.messages,
-                stream: false,
-                ...request.options || {}
-              }),
-              signal: AbortSignal.timeout(12e4)
-            });
-            if (!resp.ok) throw new Error(`Ollama ${resp.status}`);
-            const data = await resp.json();
-            sendResponse({ success: true, content: data.message?.content || "" });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "ollama.generate": {
-          try {
-            const stored = await browser.storage.local.get(["ollamaUrl"]);
-            const url = stored.ollamaUrl || "http://localhost:11434";
-            const resp = await fetch(`${url}/api/generate`, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({
-                model: request.model,
-                prompt: request.prompt,
-                stream: false,
-                ...request.options || {}
-              }),
-              signal: AbortSignal.timeout(12e4)
-            });
-            if (!resp.ok) throw new Error(`Ollama ${resp.status}`);
-            const data = await resp.json();
-            sendResponse({ success: true, content: data.response || "" });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "ollama.embed": {
-          try {
-            const stored = await browser.storage.local.get(["ollamaUrl"]);
-            const url = stored.ollamaUrl || "http://localhost:11434";
-            const resp = await fetch(`${url}/api/embeddings`, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ model: request.model, prompt: request.input }),
-              signal: AbortSignal.timeout(3e4)
-            });
-            if (!resp.ok) throw new Error(`Ollama ${resp.status}`);
-            const data = await resp.json();
-            sendResponse({ success: true, embedding: data.embedding || [] });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "ollama.status": {
-          const stored = await browser.storage.local.get(["ollamaUrl"]);
-          sendResponse({ success: true, url: stored.ollamaUrl || "http://localhost:11434", available: false });
-          break;
-        }
-        case "ollama.setUrl": {
-          await browser.storage.local.set({ ollamaUrl: request.url });
-          sendResponse({ success: true });
-          break;
-        }
-        case "ollama.pull": {
-          try {
-            const stored = await browser.storage.local.get(["ollamaUrl"]);
-            const url = stored.ollamaUrl || "http://localhost:11434";
-            fetch(`${url}/api/pull`, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ name: request.model, stream: false })
-            }).then(() => {
-              browser.storage.local.set({ "ollama.pull.progress": { model: request.model, status: "done", timestamp: Date.now() } });
-            }).catch((e) => {
-              browser.storage.local.set({ "ollama.pull.progress": { model: request.model, status: "error", error: e.message, timestamp: Date.now() } });
-            });
-            sendResponse({ success: true, started: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "ollama.delete": {
-          try {
-            const stored = await browser.storage.local.get(["ollamaUrl"]);
-            const url = stored.ollamaUrl || "http://localhost:11434";
-            await fetch(`${url}/api/delete`, {
-              method: "DELETE",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ name: request.model })
-            });
-            sendResponse({ success: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // =======================================================================
-        // Local LLM Provider (unified — Ollama / LM Studio / Hanzo Desktop)
-        // =======================================================================
-        case "local.chat": {
-          try {
-            const provider = request.provider || "ollama";
-            const endpoint = request.endpoint;
-            const model = request.model;
-            const messages = request.messages;
-            const options = request.options || {};
-            let result;
-            if (provider === "ollama" && !endpoint) {
-              const stored = await browser.storage.local.get(["ollamaUrl"]);
-              const url = stored.ollamaUrl || "http://localhost:11434";
-              const resp = await fetch(`${url}/api/chat`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ model, messages, stream: false, ...options }),
-                signal: AbortSignal.timeout(12e4)
-              });
-              if (!resp.ok) throw new Error(`Ollama ${resp.status}`);
-              const data = await resp.json();
-              result = data.message?.content || "";
-            } else if (provider === "anthropic") {
-              const baseUrl = endpoint || "https://api.anthropic.com";
-              const systemMsg = messages.find((m) => m.role === "system");
-              const chatMsgs = messages.filter((m) => m.role !== "system");
-              const body = { model, max_tokens: options.num_predict || 4096, messages: chatMsgs, stream: false };
-              if (systemMsg) body.system = systemMsg.content;
-              if (options.temperature !== void 0) body.temperature = options.temperature;
-              const resp = await fetch(`${baseUrl}/v1/messages`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json", "x-api-key": request.apiKey || "", "anthropic-version": "2023-06-01" },
-                body: JSON.stringify(body),
-                signal: AbortSignal.timeout(12e4)
-              });
-              if (!resp.ok) throw new Error(`Anthropic: ${resp.status} ${await resp.text()}`);
-              const data = await resp.json();
-              result = data.content?.[0]?.text || "";
-            } else {
-              const lpCfg = LOCAL_PROVIDER_DEFAULTS[provider];
-              const baseUrl = endpoint || (lpCfg ? `${lpCfg.url}/v1` : "http://localhost:8080/v1");
-              const headers = { "Content-Type": "application/json" };
-              if (request.apiKey) headers["Authorization"] = `Bearer ${request.apiKey}`;
-              const body = { model, messages, stream: false };
-              if (options.temperature !== void 0) body.temperature = options.temperature;
-              if (options.num_predict !== void 0) body.max_tokens = options.num_predict;
-              const resp = await fetch(`${baseUrl}/chat/completions`, {
-                method: "POST",
-                headers,
-                body: JSON.stringify(body),
-                signal: AbortSignal.timeout(12e4)
-              });
-              if (!resp.ok) throw new Error(`${provider}: ${resp.status} ${await resp.text()}`);
-              const data = await resp.json();
-              result = data.choices?.[0]?.message?.content || "";
-            }
-            sendResponse({ success: true, content: result });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "local.models": {
-          try {
-            const lpCfg2 = LOCAL_PROVIDER_DEFAULTS[request.provider];
-            const endpoint = request.endpoint || (request.provider === "ollama" ? null : lpCfg2 ? `${lpCfg2.url}/v1` : request.endpoint || "http://localhost:8080/v1");
-            if (!endpoint) {
-              const stored = await browser.storage.local.get(["ollamaUrl"]);
-              const url = stored.ollamaUrl || LOCAL_PROVIDER_DEFAULTS.ollama.url;
-              const resp2 = await fetch(`${url}/api/tags`, { signal: AbortSignal.timeout(5e3) });
-              if (!resp2.ok) throw new Error(`HTTP ${resp2.status}`);
-              const data2 = await resp2.json();
-              sendResponse({ success: true, models: (data2.models || []).map((m) => ({ id: m.name, name: m.name, size: m.size, details: m.details })) });
-              break;
-            }
-            const headers = {};
-            if (request.apiKey) headers["Authorization"] = `Bearer ${request.apiKey}`;
-            const resp = await fetch(`${endpoint}/models`, { headers, signal: AbortSignal.timeout(5e3) });
-            if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-            const data = await resp.json();
-            sendResponse({ success: true, models: data.data || data.models || [] });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "local.discover": {
-          const providers = [];
-          try {
-            const stored2 = await browser.storage.local.get(["ollamaUrl"]);
-            const url = stored2.ollamaUrl || LOCAL_PROVIDER_DEFAULTS.ollama.url;
-            const resp = await fetch(`${url}/api/tags`, { signal: AbortSignal.timeout(2e3) });
-            if (resp.ok) {
-              const data = await resp.json();
-              providers.push({ name: "ollama", url, available: true, models: (data.models || []).map((m) => m.name) });
-            } else {
-              providers.push({ name: "ollama", url, available: false });
-            }
-          } catch {
-            providers.push({ name: "ollama", url: LOCAL_PROVIDER_DEFAULTS.ollama.url, available: false });
-          }
-          {
-            const lmsCfg = LOCAL_PROVIDER_DEFAULTS.lmstudio;
-            try {
-              const resp = await fetch(`${lmsCfg.url}/models`, { signal: AbortSignal.timeout(2e3) });
-              if (resp.ok) {
-                const data = await resp.json();
-                providers.push({ name: "lmstudio", url: lmsCfg.url, available: true, models: (data.data || []).map((m) => m.id) });
-              } else {
-                providers.push({ name: "lmstudio", url: lmsCfg.url, available: false });
-              }
-            } catch {
-              providers.push({ name: "lmstudio", url: lmsCfg.url, available: false });
-            }
-          }
-          {
-            const hdCfg = LOCAL_PROVIDER_DEFAULTS["hanzo-desktop"];
-            for (const port of hdCfg.probePorts) {
-              try {
-                const resp = await fetch(`http://localhost:${port}/api/tags`, { signal: AbortSignal.timeout(2e3) });
-                if (resp.ok) {
-                  const data = await resp.json();
-                  providers.push({ name: "hanzo-desktop", url: `http://localhost:${port}`, available: true, models: (data.models || []).map((m) => m.name) });
-                  break;
-                }
-              } catch {
-              }
-            }
-            if (!providers.find((p) => p.name === "hanzo-desktop")) {
-              providers.push({ name: "hanzo-desktop", url: hdCfg.url, available: false });
-            }
-          }
-          const stored = await browser.storage.local.get(["customLLMEndpoints"]);
-          const customs = stored.customLLMEndpoints || [];
-          for (const c of customs) {
-            try {
-              const headers = {};
-              if (c.apiKey) headers["Authorization"] = `Bearer ${c.apiKey}`;
-              const resp = await fetch(`${c.url}/models`, { headers, signal: AbortSignal.timeout(3e3) });
-              if (resp.ok) {
-                const data = await resp.json();
-                providers.push({ name: c.name || "custom", url: c.url, available: true, models: (data.data || data.models || []).map((m) => m.id || m.name) });
-              } else {
-                providers.push({ name: c.name || "custom", url: c.url, available: false });
-              }
-            } catch {
-              providers.push({ name: c.name || "custom", url: c.url, available: false });
-            }
-          }
-          sendResponse({ success: true, providers });
-          break;
-        }
-        // =======================================================================
-        // Provider Management
-        // =======================================================================
-        case "provider.save": {
-          try {
-            const stored = await browser.storage.local.get(["customLLMEndpoints"]);
-            const endpoints = stored.customLLMEndpoints || [];
-            const existing = endpoints.findIndex((e) => e.name === request.name || e.url === request.url);
-            const entry = { name: request.name, url: request.url, apiKey: request.apiKey };
-            if (existing >= 0) endpoints[existing] = entry;
-            else endpoints.push(entry);
-            await browser.storage.local.set({ customLLMEndpoints: endpoints });
-            sendResponse({ success: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "provider.remove": {
-          try {
-            const stored = await browser.storage.local.get(["customLLMEndpoints"]);
-            const endpoints = (stored.customLLMEndpoints || []).filter(
-              (e) => e.name !== request.name && e.url !== request.url
-            );
-            await browser.storage.local.set({ customLLMEndpoints: endpoints });
-            sendResponse({ success: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "provider.test": {
-          try {
-            const headers = {};
-            if (request.apiKey) headers["Authorization"] = `Bearer ${request.apiKey}`;
-            const resp = await fetch(`${request.url}/models`, { headers, signal: AbortSignal.timeout(5e3) });
-            if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-            const data = await resp.json();
-            sendResponse({ success: true, models: (data.data || data.models || []).map((m) => m.id || m.name) });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // =======================================================================
-        // Settings (browser.storage.local)
-        // =======================================================================
-        case "settings.get": {
-          try {
-            const keys = request.keys || [
-              "selectedProvider",
-              "selectedModel",
-              "customLLMEndpoints",
-              "ollamaUrl",
-              "anthropicApiKey",
-              "openaiApiKey",
-              "hanzoApiKey",
-              "mcpPort",
-              "cdpPort",
-              "zapPorts",
-              "activeOrgId",
-              "browserBackend"
-            ];
-            const result = await browser.storage.local.get(keys);
-            sendResponse({ success: true, settings: result });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "settings.set": {
-          try {
-            await browser.storage.local.set(request.settings);
-            sendResponse({ success: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "settings.export": {
-          try {
-            const all = await browser.storage.local.get(null);
-            const safe = {};
-            for (const [k, v] of Object.entries(all)) {
-              if (k.startsWith("hanzo_iam_")) continue;
-              safe[k] = v;
-            }
-            sendResponse({ success: true, settings: safe });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "settings.import": {
-          try {
-            const settings = request.settings || {};
-            delete settings.hanzo_iam_access_token;
-            delete settings.hanzo_iam_refresh_token;
-            delete settings.hanzo_iam_id_token;
-            await browser.storage.local.set(settings);
-            sendResponse({ success: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "settings.sync":
-          sendResponse({ success: true });
-          break;
-        case "config.save": {
-          try {
-            if (request.key) {
-              await browser.storage.local.set({ [request.key]: request.value });
-            }
-            sendResponse({ success: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // =======================================================================
-        // API Key Management
-        // =======================================================================
-        case "apikey.save": {
-          try {
-            await browser.storage.local.set({ [`apikey_${request.provider}`]: request.apiKey });
-            sendResponse({ success: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "apikey.get": {
-          try {
-            const key = `apikey_${request.provider}`;
-            const stored = await browser.storage.local.get([key]);
-            sendResponse({ success: true, apiKey: stored[key] || null });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "apikey.list": {
-          try {
-            const all = await browser.storage.local.get(null);
-            const keys = [];
-            for (const [k] of Object.entries(all)) {
-              if (k.startsWith("apikey_")) {
-                keys.push({ provider: k.replace("apikey_", ""), hasKey: true });
-              }
-            }
-            sendResponse({ success: true, keys });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // =======================================================================
-        // Organization Switcher
-        // =======================================================================
-        case "org.list": {
-          try {
-            const token = await getValidAccessToken2();
-            if (!token) {
-              sendResponse({ success: false, error: "Not authenticated" });
-              break;
-            }
-            const resp = await fetch(`${IAM_V1}/get-account`, {
-              headers: { Authorization: `Bearer ${token}` },
-              signal: AbortSignal.timeout(5e3)
-            });
-            if (!resp.ok) throw new Error(`IAM: ${resp.status}`);
-            const data = await resp.json();
-            const user = data.data || data;
-            const orgs = [];
-            if (user.owner) {
-              orgs.push({ id: user.owner, name: user.owner, displayName: user.owner });
-            }
-            try {
-              const orgsResp = await fetch(`${IAM_V1}/get-organizations`, {
-                headers: { Authorization: `Bearer ${token}` },
-                signal: AbortSignal.timeout(5e3)
-              });
-              if (orgsResp.ok) {
-                const orgsData = await orgsResp.json();
-                for (const org of orgsData.data || orgsData || []) {
-                  if (!orgs.find((o) => o.id === org.name)) {
-                    orgs.push({ id: org.name, name: org.name, displayName: org.displayName || org.name });
-                  }
-                }
-              }
-            } catch {
-            }
-            const stored = await browser.storage.local.get(["activeOrgId"]);
-            sendResponse({
-              success: true,
-              orgs,
-              activeOrgId: stored.activeOrgId || orgs[0]?.id || null,
-              user: { name: user.displayName || user.name, email: user.email, avatar: user.avatar }
-            });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "org.switch": {
-          try {
-            await browser.storage.local.set({ activeOrgId: request.orgId });
-            sendResponse({ success: true, activeOrgId: request.orgId });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // =======================================================================
-        // Model Hub (portable — pure HTTP/fetch)
-        // =======================================================================
-        case "hub.search": {
-          try {
-            const query = encodeURIComponent(request.query || "");
-            const limit = request.limit || 10;
-            const resp = await fetch(
-              `https://huggingface.co/api/models?search=${query}&limit=${limit}&sort=downloads&direction=-1`,
-              { signal: AbortSignal.timeout(1e4) }
-            );
-            if (!resp.ok) throw new Error(`HuggingFace ${resp.status}`);
-            sendResponse({ success: true, models: await resp.json() });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "hub.model": {
-          try {
-            const resp = await fetch(`https://huggingface.co/api/models/${request.modelId}`, { signal: AbortSignal.timeout(1e4) });
-            if (!resp.ok) throw new Error(`HuggingFace ${resp.status}`);
-            sendResponse({ success: true, model: await resp.json() });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        case "hub.recommended":
-          sendResponse({ success: true, models: [] });
-          break;
-        case "hub.searchOllama": {
-          try {
-            const resp = await fetch(`https://ollama.com/api/tags?q=${encodeURIComponent(request.query || "")}`, { signal: AbortSignal.timeout(1e4) });
-            if (resp.ok) {
-              sendResponse({ success: true, models: await resp.json() });
-            } else {
-              sendResponse({ success: true, models: [] });
-            }
-          } catch {
-            sendResponse({ success: true, models: [] });
-          }
-          break;
-        }
-        case "hub.searchGGUF":
-        case "hub.searchMLX":
-        case "hub.modelCard":
-        case "hub.modelStats":
-        case "hub.allModels":
-          sendResponse({ success: true, models: [], card: null, stats: null, cloud: [], local: [], recommended: [] });
-          break;
-        case "hub.downloadOllama": {
-          try {
-            const stored = await browser.storage.local.get(["ollamaUrl"]);
-            const url = stored.ollamaUrl || "http://localhost:11434";
-            fetch(`${url}/api/pull`, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ name: request.modelName, stream: false })
-            }).catch(() => {
-            });
-            sendResponse({ success: true });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // =======================================================================
-        // Element Selected (forward to ZAP-connected MCPs)
-        // =======================================================================
-        case "elementSelected": {
-          if (zapMgr.state.connected) {
-            for (const [mcpId] of zapMgr.connections) {
-              zapRequest(zapMgr, mcpId, "notifications/elementSelected", request.data || {}).catch(() => {
-              });
-            }
-          }
-          sendResponse({ success: true });
-          break;
-        }
-        // =======================================================================
-        // Page Overlay (forwarded to content script)
-        // =======================================================================
-        case "page.overlay.toggle":
-        case "page.overlay.show":
-        case "page.overlay.hide":
-        case "page.overlay.status": {
-          try {
-            const tabId = typeof request.tabId === "number" ? request.tabId : sender?.tab?.id ?? await hanzoExtension.getActiveTabId();
-            if (!tabId) {
-              sendResponse({ success: false, error: "No target tab found" });
-              break;
-            }
-            const response = await browser.tabs.sendMessage(tabId, { action: request.action }).catch(() => ({}));
-            sendResponse({ success: true, tabId, ...response || {} });
-          } catch (e) {
-            sendResponse({ success: false, error: e.message });
-          }
-          break;
-        }
-        // =======================================================================
-        // Takeover (control session management)
-        // =======================================================================
-        case "hanzo.takeover.start": {
-          const takeoverTabId = request.tabId || controlSession.tabId || await hanzoExtension.getActiveTabId();
-          if (!takeoverTabId) {
-            sendResponse({ success: false, error: "No target tab found" });
-            break;
-          }
-          await hanzoExtension.startControlSession(takeoverTabId, request.task);
-          sendResponse({ success: true });
-          break;
-        }
-        case "hanzo.takeover.end": {
-          await hanzoExtension.stopControlSession();
-          sendResponse({ success: true });
-          break;
-        }
-        case "hanzo.takeover.cursor": {
-          const cursorTabId = controlSession.tabId || await hanzoExtension.getActiveTabId();
-          if (cursorTabId) {
-            browser.tabs.sendMessage(cursorTabId, {
-              action: "ai.control.cursor",
-              x: request.x,
-              y: request.y
-            }).catch(() => {
-            });
-          }
-          sendResponse({ success: true });
-          break;
-        }
-        // =======================================================================
-        // Bridge & Usage
-        // =======================================================================
-        case "bridge.status": {
-          const bridgeConnected = hanzoExtension.isBridgeConnected();
-          sendResponse({
-            success: true,
-            connected: bridgeConnected,
-            browsers: bridgeConnected ? ["firefox"] : []
-          });
-          break;
-        }
-        case "usage.metrics":
-          sendResponse({ success: true, metrics: { chatRequests: 0, inputTokens: 0, outputTokens: 0, dedupeHits: 0, canceledRequests: 0 } });
-          break;
-        case "inspector.pickResult":
-          sendResponse({ success: true });
-          break;
-        // =======================================================================
-        // AI Control Overlay (forwarded to content script)
-        // =======================================================================
-        case "ai.control.start":
-        case "ai.control.cursor":
-        case "ai.control.highlight":
-        case "ai.control.status": {
-          const targetTabId = request.tabId || controlSession.tabId || await hanzoExtension.getActiveTabId();
-          if (!targetTabId) {
-            sendResponse({ success: false, error: "No target tab found" });
-            break;
-          }
-          if (request.action !== "ai.control.start" && controlSession.active && controlSession.tabId && targetTabId !== controlSession.tabId) {
-            sendResponse({ success: false, error: `Control locked to tab ${controlSession.tabId}` });
-            break;
-          }
-          if (request.action === "ai.control.start") {
-            await hanzoExtension.startControlSession(targetTabId, request.task);
-          } else {
-            browser.tabs.sendMessage(targetTabId, request).catch(() => {
-            });
-          }
-          sendResponse({ success: true, tabId: targetTabId });
-          break;
-        }
-        case "ai.control.stop":
-          await hanzoExtension.stopControlSession();
-          sendResponse({ success: true });
-          break;
-        case "ai.control.cancel":
-          await hanzoExtension.stopControlSession();
-          sendResponse({ success: true });
-          break;
-        // =======================================================================
-        // CDP-specific stubs (not available in Firefox — chrome.debugger is Chrome-only)
-        // =======================================================================
-        case "cdp.attach":
-        case "cdp.detach":
-        case "cdp.send":
-        case "cdp.screenshot":
-        case "cdp.click":
-        case "cdp.fill":
-        case "cdp.navigate":
-        case "cdp.evaluate":
-          sendResponse({ success: false, error: "CDP debugger is not available in Firefox. Use browser automation methods instead." });
-          break;
-        // Monitor stubs (CDP-dependent in Chrome, limited in Firefox)
-        case "monitor.start":
-        case "monitor.stop":
-        case "monitor.consoleLogs":
-        case "monitor.consoleErrors":
-        case "monitor.networkLogs":
-        case "monitor.networkErrors":
-        case "monitor.networkSuccess":
-        case "monitor.allNetwork":
-        case "monitor.wipeLogs":
-        case "monitor.config":
-        case "monitor.status":
-          sendResponse({ success: false, error: "Page monitoring requires CDP (Chrome DevTools Protocol) which is not available in Firefox." });
-          break;
-        // Audit stubs
-        case "audit.accessibility":
-        case "audit.performance":
-        case "audit.seo":
-        case "audit.bestPractices":
-        case "audit.full":
-        case "audit.nextjs":
-        case "audit.debugger":
-        case "debugger.mode":
-          sendResponse({ success: false, error: "Page audits require CDP which is not available in Firefox." });
-          break;
-        // Tab filesystem (requires CDP bridge)
-        case "readTabFS":
-        case "writeTabFS":
-        case "listTabFS":
-          sendResponse({ success: false, error: "Tab filesystem requires CDP bridge." });
-          break;
-        default:
-          sendResponse({ success: false, error: `Unknown action: ${request.action}` });
-          break;
-      }
-    })();
-    return true;
-  });
-  var hanzoExtension = new HanzoFirefoxExtension();
-  var BROWSER_CAPS = ["browser.tabs", "browser.navigate", "browser.dom", "browser.screenshot", "browser.input"];
-  var nativeZap = {
-    connected: false,
-    port: null,
-    providerId: `browser:${BROWSER_NAME}/default`
-  };
-  var browserDispatch = (method, params) => hanzoExtension.dispatchMethod(method, params || {});
-  connectNativeZap(nativeZap, "hanzo", BROWSER_CAPS, browserDispatch, console.log);
-  browser.runtime.onConnect.addListener((port) => {
-    if (port.name !== "zap-keepalive") return;
-    port.onMessage.addListener(() => {
-    });
-  });
-  var KEEP_ALIVE_ALARM = "hanzo-zap-keepalive";
-  try {
-    browser.alarms.create(KEEP_ALIVE_ALARM, { periodInMinutes: 0.25 });
-    browser.alarms.onAlarm.addListener((alarm) => {
-      if (alarm.name !== KEEP_ALIVE_ALARM) return;
-      if (!nativeZap.connected) {
-        console.log("[Hanzo/ZAP] keep-alive: reconnecting native host");
-        connectNativeZap(nativeZap, "hanzo", BROWSER_CAPS, browserDispatch, console.log);
-      }
-    });
-  } catch (e) {
-    console.warn("[Hanzo] alarms unavailable:", e);
-  }
-  browser.tabs.onRemoved.addListener((tabId) => {
-    if (controlSession.active && controlSession.tabId === tabId) {
-      void hanzoExtension.stopControlSession();
-    }
-  });
-  console.log("[Hanzo] Firefox background script loaded");
-})();