@hanzo/browser-extension 1.7.6 → 1.9.33

package/dist/browser-extension/background.js

@@ -1,2732 +0,0 @@
-// src/browser-control.ts
-var BrowserControl = class {
-  constructor() {
-    this.tabFS = /* @__PURE__ */ new Map();
-    this.aiWorkers = /* @__PURE__ */ new Map();
-    this.agents = /* @__PURE__ */ new Map();
-    this.initializeTabFileSystem();
-    this.setupMessageHandlers();
-  }
-  initializeTabFileSystem() {
-    if (typeof chrome === "undefined" || !chrome.tabs) return;
-    chrome.tabs.query({}, (tabs) => {
-      tabs.forEach((tab, index) => {
-        if (tab.id && tab.url) {
-          const path = `/tabs/${index}/${this.sanitizePath(tab.title || "untitled")}`;
-          this.tabFS.set(path, {
-            path,
-            tabId: tab.id,
-            url: tab.url,
-            title: tab.title || "Untitled"
-          });
-        }
-      });
-    });
-    chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
-      if (changeInfo.status === "complete") {
-        this.updateTabFS(tab);
-      }
-    });
-    chrome.tabs.onRemoved.addListener((tabId) => {
-      for (const [path, entry] of this.tabFS) {
-        if (entry.tabId === tabId) {
-          this.tabFS.delete(path);
-          break;
-        }
-      }
-    });
-  }
-  sanitizePath(title) {
-    return title.replace(/[^a-zA-Z0-9-_]/g, "_").toLowerCase().substring(0, 60);
-  }
-  updateTabFS(tab) {
-    if (!tab.id || !tab.url) return;
-    const existingEntry = Array.from(this.tabFS.values()).find(
-      (entry) => entry.tabId === tab.id
-    );
-    const path = (existingEntry == null ? void 0 : existingEntry.path) || `/tabs/${this.tabFS.size}/${this.sanitizePath(tab.title || "untitled")}`;
-    this.tabFS.set(path, {
-      path,
-      tabId: tab.id,
-      url: tab.url,
-      title: tab.title || "Untitled"
-    });
-  }
-  // ===========================================================================
-  // FUSE-like Tab Filesystem
-  // ===========================================================================
-  async readTab(path) {
-    const entry = this.tabFS.get(path);
-    if (!entry) throw new Error(`Tab not found: ${path}`);
-    return new Promise((resolve, reject) => {
-      chrome.tabs.sendMessage(entry.tabId, { action: "getContent" }, (response) => {
-        if (chrome.runtime.lastError) {
-          reject(new Error(chrome.runtime.lastError.message));
-        } else {
-          resolve((response == null ? void 0 : response.content) || "");
-        }
-      });
-    });
-  }
-  async writeTab(path, content) {
-    const entry = this.tabFS.get(path);
-    if (!entry) throw new Error(`Tab not found: ${path}`);
-    return new Promise((resolve, reject) => {
-      chrome.tabs.sendMessage(entry.tabId, { action: "setContent", content }, (response) => {
-        if (chrome.runtime.lastError) {
-          reject(new Error(chrome.runtime.lastError.message));
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-  async listTabs() {
-    return Array.from(this.tabFS.keys());
-  }
-  // ===========================================================================
-  // Native Browser Actions
-  // ===========================================================================
-  async click(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.scrollIntoView({ behavior: 'smooth', block: 'center' });
-        el.click();
-        return true;
-      })()
-    `);
-  }
-  async clickAtPoint(tabId, x, y) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.elementFromPoint(${x}, ${y});
-        if (!el) return false;
-        el.dispatchEvent(new MouseEvent('click', { bubbles: true, clientX: ${x}, clientY: ${y} }));
-        return true;
-      })()
-    `);
-  }
-  async doubleClick(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.scrollIntoView({ behavior: 'smooth', block: 'center' });
-        el.dispatchEvent(new MouseEvent('dblclick', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async type(tabId, selector, text) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.focus();
-        for (const char of ${JSON.stringify(text)}) {
-          el.dispatchEvent(new KeyboardEvent('keydown', { key: char, bubbles: true }));
-          el.dispatchEvent(new KeyboardEvent('keypress', { key: char, bubbles: true }));
-          if ('value' in el) el.value += char;
-          el.dispatchEvent(new InputEvent('input', { data: char, inputType: 'insertText', bubbles: true }));
-          el.dispatchEvent(new KeyboardEvent('keyup', { key: char, bubbles: true }));
-        }
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async fill(tabId, selector, value) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.focus();
-        const nativeSetter = Object.getOwnPropertyDescriptor(
-          Object.getPrototypeOf(el), 'value'
-        )?.set || Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
-        if (nativeSetter) {
-          nativeSetter.call(el, ${JSON.stringify(value)});
-        } else {
-          el.value = ${JSON.stringify(value)};
-        }
-        el.dispatchEvent(new Event('input', { bubbles: true }));
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async select(tabId, selector, value) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el || el.tagName !== 'SELECT') return false;
-        el.value = ${JSON.stringify(value)};
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async check(tabId, selector, checked) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        if (el.checked !== ${checked}) el.click();
-        return true;
-      })()
-    `);
-  }
-  async hover(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.dispatchEvent(new MouseEvent('mouseenter', { bubbles: true }));
-        el.dispatchEvent(new MouseEvent('mouseover', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async focus(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.focus();
-        return true;
-      })()
-    `);
-  }
-  async blur(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.blur();
-        return true;
-      })()
-    `);
-  }
-  async scroll(tabId, x, y, selector) {
-    if (selector) {
-      return this.executeScript(tabId, `
-        (() => {
-          const el = document.querySelector(${JSON.stringify(selector)});
-          if (!el) return false;
-          el.scrollBy({ left: ${x}, top: ${y}, behavior: 'smooth' });
-          return true;
-        })()
-      `);
-    }
-    return this.executeScript(tabId, `
-      (() => { window.scrollBy({ left: ${x}, top: ${y}, behavior: 'smooth' }); return true; })()
-    `);
-  }
-  async scrollIntoView(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return false;
-        el.scrollIntoView({ behavior: 'smooth', block: 'center', inline: 'nearest' });
-        return true;
-      })()
-    `);
-  }
-  async pressKey(tabId, key, modifiers = {}) {
-    return this.executeScript(tabId, `
-      (() => {
-        const opts = {
-          key: ${JSON.stringify(key)},
-          code: ${JSON.stringify(key)},
-          bubbles: true,
-          ctrlKey: ${!!modifiers.ctrl},
-          shiftKey: ${!!modifiers.shift},
-          altKey: ${!!modifiers.alt},
-          metaKey: ${!!modifiers.meta},
-        };
-        document.activeElement.dispatchEvent(new KeyboardEvent('keydown', opts));
-        document.activeElement.dispatchEvent(new KeyboardEvent('keypress', opts));
-        document.activeElement.dispatchEvent(new KeyboardEvent('keyup', opts));
-        return true;
-      })()
-    `);
-  }
-  async drag(tabId, fromSelector, toSelector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const from = document.querySelector(${JSON.stringify(fromSelector)});
-        const to = document.querySelector(${JSON.stringify(toSelector)});
-        if (!from || !to) return false;
-        const fromRect = from.getBoundingClientRect();
-        const toRect = to.getBoundingClientRect();
-        const fromX = fromRect.left + fromRect.width / 2;
-        const fromY = fromRect.top + fromRect.height / 2;
-        const toX = toRect.left + toRect.width / 2;
-        const toY = toRect.top + toRect.height / 2;
-        from.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, clientX: fromX, clientY: fromY }));
-        from.dispatchEvent(new MouseEvent('mousemove', { bubbles: true, clientX: toX, clientY: toY }));
-        to.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, clientX: toX, clientY: toY }));
-        to.dispatchEvent(new DragEvent('drop', { bubbles: true }));
-        return true;
-      })()
-    `);
-  }
-  async waitForSelector(tabId, selector, timeoutMs = 1e4) {
-    return this.executeScript(tabId, `
-      new Promise((resolve) => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (el) { resolve(true); return; }
-        const observer = new MutationObserver(() => {
-          if (document.querySelector(${JSON.stringify(selector)})) {
-            observer.disconnect();
-            resolve(true);
-          }
-        });
-        observer.observe(document.body, { childList: true, subtree: true });
-        setTimeout(() => { observer.disconnect(); resolve(false); }, ${timeoutMs});
-      })
-    `);
-  }
-  async waitForNavigation(tabId, timeoutMs = 3e4) {
-    return new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        chrome.tabs.onUpdated.removeListener(listener);
-        resolve(false);
-      }, timeoutMs);
-      const listener = (updatedTabId, changeInfo) => {
-        if (updatedTabId === tabId && changeInfo.status === "complete") {
-          clearTimeout(timer);
-          chrome.tabs.onUpdated.removeListener(listener);
-          resolve(true);
-        }
-      };
-      chrome.tabs.onUpdated.addListener(listener);
-    });
-  }
-  async evaluate(tabId, expression) {
-    return this.executeScript(tabId, expression);
-  }
-  async getElementInfo(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return null;
-        const rect = el.getBoundingClientRect();
-        const styles = window.getComputedStyle(el);
-        return {
-          tagName: el.tagName.toLowerCase(),
-          id: el.id,
-          className: el.className,
-          textContent: el.textContent?.substring(0, 500),
-          innerText: el.innerText?.substring(0, 500),
-          value: el.value,
-          href: el.href,
-          src: el.src,
-          type: el.type,
-          checked: el.checked,
-          disabled: el.disabled,
-          visible: styles.display !== 'none' && styles.visibility !== 'hidden' && rect.width > 0 && rect.height > 0,
-          rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
-          attributes: Object.fromEntries(Array.from(el.attributes).map(a => [a.name, a.value])),
-        };
-      })()
-    `);
-  }
-  async getPageInfo(tabId) {
-    return this.executeScript(tabId, `
-      (() => ({
-        url: location.href,
-        title: document.title,
-        readyState: document.readyState,
-        scrollX: window.scrollX,
-        scrollY: window.scrollY,
-        innerWidth: window.innerWidth,
-        innerHeight: window.innerHeight,
-        documentWidth: document.documentElement.scrollWidth,
-        documentHeight: document.documentElement.scrollHeight,
-        forms: document.forms.length,
-        links: document.links.length,
-        images: document.images.length,
-      }))()
-    `);
-  }
-  async querySelectorAll(tabId, selector) {
-    return this.executeScript(tabId, `
-      (() => Array.from(document.querySelectorAll(${JSON.stringify(selector)})).slice(0, 100).map((el, i) => ({
-        index: i,
-        tagName: el.tagName.toLowerCase(),
-        id: el.id,
-        className: el.className,
-        textContent: el.textContent?.substring(0, 200),
-        visible: el.offsetWidth > 0 && el.offsetHeight > 0,
-      })))()
-    `);
-  }
-  // ===========================================================================
-  // Navigation
-  // ===========================================================================
-  async navigateTo(tabId, url) {
-    chrome.tabs.update(tabId, { url });
-  }
-  async reload(tabId) {
-    chrome.tabs.reload(tabId);
-  }
-  async goBack(tabId) {
-    chrome.tabs.goBack(tabId);
-  }
-  async goForward(tabId) {
-    chrome.tabs.goForward(tabId);
-  }
-  async createTab(url, active = true) {
-    return new Promise((resolve) => {
-      chrome.tabs.create({ url, active }, (tab) => {
-        resolve(tab.id);
-      });
-    });
-  }
-  async closeTab(tabId) {
-    chrome.tabs.remove(tabId);
-  }
-  // ===========================================================================
-  // Screenshots
-  // ===========================================================================
-  async captureScreenshot(tabId, options) {
-    return new Promise((resolve, reject) => {
-      const format = (options == null ? void 0 : options.format) || "jpeg";
-      const quality = (options == null ? void 0 : options.quality) || (format === "jpeg" ? 80 : void 0);
-      const captureOpts = { format };
-      if (quality !== void 0) captureOpts.quality = quality;
-      chrome.tabs.captureVisibleTab(captureOpts, (dataUrl) => {
-        if (chrome.runtime.lastError) {
-          reject(new Error(chrome.runtime.lastError.message));
-        } else {
-          resolve(dataUrl);
-        }
-      });
-    });
-  }
-  async captureFullPage(tabId) {
-    const pageInfo = await this.getPageInfo(tabId);
-    return this.captureScreenshot(tabId, { format: "png" });
-  }
-  // ===========================================================================
-  // AI Worker Management
-  // ===========================================================================
-  async launchAIWorker(tabId, modelName) {
-    const worker = new Worker(new URL("./ai-worker.js", import.meta.url), {
-      type: "module"
-    });
-    const agentId = `agent-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 8)}`;
-    worker.postMessage({ type: "init", payload: { tabId, modelName } });
-    worker.onmessage = (event) => {
-      this.handleAIWorkerMessage(tabId, agentId, event.data);
-    };
-    worker.onerror = (event) => {
-      console.error(`[Hanzo] AI worker error for tab ${tabId}:`, event.message);
-      const agent = this.agents.get(agentId);
-      if (agent) agent.status = "error";
-    };
-    this.aiWorkers.set(tabId, worker);
-    this.agents.set(agentId, {
-      id: agentId,
-      name: modelName,
-      tabId,
-      status: "running",
-      worker
-    });
-    return agentId;
-  }
-  stopAgent(agentId) {
-    const agent = this.agents.get(agentId);
-    if (!agent) return false;
-    agent.worker.terminate();
-    agent.status = "stopped";
-    this.aiWorkers.delete(agent.tabId);
-    this.agents.delete(agentId);
-    return true;
-  }
-  getAgents() {
-    return Array.from(this.agents.values()).map((a) => ({
-      id: a.id,
-      name: a.name,
-      tabId: a.tabId,
-      status: a.status
-    }));
-  }
-  handleAIWorkerMessage(tabId, agentId, data) {
-    switch (data.type) {
-      case "click":
-        this.click(tabId, data.selector);
-        break;
-      case "type":
-        this.type(tabId, data.selector, data.text);
-        break;
-      case "fill":
-        this.fill(tabId, data.selector, data.value);
-        break;
-      case "navigate":
-        this.navigateTo(tabId, data.url);
-        break;
-      case "scroll":
-        this.scroll(tabId, data.x || 0, data.y || 0, data.selector);
-        break;
-      case "hover":
-        this.hover(tabId, data.selector);
-        break;
-      case "select":
-        this.select(tabId, data.selector, data.value);
-        break;
-      case "pressKey":
-        this.pressKey(tabId, data.key, data.modifiers);
-        break;
-      case "waitForSelector":
-        this.waitForSelector(tabId, data.selector, data.timeout).then((found) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker == null ? void 0 : worker.postMessage({ type: "waitResult", found });
-        });
-        break;
-      case "evaluate":
-        this.evaluate(tabId, data.expression).then((result) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker == null ? void 0 : worker.postMessage({ type: "evalResult", result });
-        });
-        break;
-      case "screenshot":
-        this.captureScreenshot(tabId).then((screenshot) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker == null ? void 0 : worker.postMessage({ type: "screenshot", data: screenshot });
-        });
-        break;
-      case "getElementInfo":
-        this.getElementInfo(tabId, data.selector).then((info) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker == null ? void 0 : worker.postMessage({ type: "elementInfo", info });
-        });
-        break;
-      case "getPageInfo":
-        this.getPageInfo(tabId).then((info) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker == null ? void 0 : worker.postMessage({ type: "pageInfo", info });
-        });
-        break;
-      case "querySelectorAll":
-        this.querySelectorAll(tabId, data.selector).then((elements) => {
-          const worker = this.aiWorkers.get(tabId);
-          worker == null ? void 0 : worker.postMessage({ type: "elements", elements });
-        });
-        break;
-      case "done":
-      case "complete": {
-        const agent = this.agents.get(agentId);
-        if (agent) {
-          agent.status = "stopped";
-          agent.worker.terminate();
-          this.aiWorkers.delete(tabId);
-          this.agents.delete(agentId);
-        }
-        break;
-      }
-    }
-  }
-  // ===========================================================================
-  // Cross-tab Communication
-  // ===========================================================================
-  async broadcastToAI(message) {
-    this.aiWorkers.forEach((worker) => {
-      worker.postMessage({ type: "broadcast", message });
-    });
-  }
-  // ===========================================================================
-  // Content Script Message Handler
-  // ===========================================================================
-  setupMessageHandlers() {
-    if (typeof chrome === "undefined" || !chrome.runtime) return;
-    chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
-      var _a, _b;
-      if (request.from === "content" && ((_a = sender.tab) == null ? void 0 : _a.id)) {
-        this.handleContentMessage(sender.tab.id, request, sendResponse);
-        return true;
-      }
-      if ((_b = request.action) == null ? void 0 : _b.startsWith("browser.")) {
-        this.handleBrowserAction(request, sendResponse);
-        return true;
-      }
-      if (request.action === "listAgents") {
-        sendResponse({ success: true, agents: this.getAgents() });
-        return true;
-      }
-      if (request.action === "stopAgent") {
-        const stopped = this.stopAgent(request.agentId);
-        sendResponse({ success: stopped });
-        return true;
-      }
-      if (request.action === "checkWebGPU") {
-        if (navigator.gpu) {
-          navigator.gpu.requestAdapter().then((adapter) => {
-            sendResponse({
-              available: !!adapter,
-              adapter: (adapter == null ? void 0 : adapter.name) || "Unknown GPU"
-            });
-          }).catch(() => {
-            sendResponse({ available: false });
-          });
-        } else {
-          sendResponse({ available: false });
-        }
-        return true;
-      }
-    });
-  }
-  async handleBrowserAction(request, sendResponse) {
-    const tabId = request.tabId;
-    try {
-      switch (request.action) {
-        case "browser.click":
-          sendResponse({ success: await this.click(tabId, request.selector) });
-          break;
-        case "browser.type":
-          sendResponse({ success: await this.type(tabId, request.selector, request.text) });
-          break;
-        case "browser.fill":
-          sendResponse({ success: await this.fill(tabId, request.selector, request.value) });
-          break;
-        case "browser.select":
-          sendResponse({ success: await this.select(tabId, request.selector, request.value) });
-          break;
-        case "browser.scroll":
-          sendResponse({ success: await this.scroll(tabId, request.x, request.y, request.selector) });
-          break;
-        case "browser.hover":
-          sendResponse({ success: await this.hover(tabId, request.selector) });
-          break;
-        case "browser.pressKey":
-          sendResponse({ success: await this.pressKey(tabId, request.key, request.modifiers) });
-          break;
-        case "browser.evaluate":
-          sendResponse({ success: true, result: await this.evaluate(tabId, request.expression) });
-          break;
-        case "browser.screenshot":
-          sendResponse({ success: true, data: await this.captureScreenshot(tabId, request.options) });
-          break;
-        case "browser.navigate":
-          await this.navigateTo(tabId, request.url);
-          sendResponse({ success: true });
-          break;
-        case "browser.waitForSelector":
-          sendResponse({ success: await this.waitForSelector(tabId, request.selector, request.timeout) });
-          break;
-        case "browser.getElementInfo":
-          sendResponse({ success: true, info: await this.getElementInfo(tabId, request.selector) });
-          break;
-        case "browser.getPageInfo":
-          sendResponse({ success: true, info: await this.getPageInfo(tabId) });
-          break;
-        case "browser.querySelectorAll":
-          sendResponse({ success: true, elements: await this.querySelectorAll(tabId, request.selector) });
-          break;
-        default:
-          sendResponse({ success: false, error: `Unknown action: ${request.action}` });
-      }
-    } catch (e) {
-      sendResponse({ success: false, error: e.message });
-    }
-  }
-  handleContentMessage(tabId, request, sendResponse) {
-    const worker = this.aiWorkers.get(tabId);
-    if (worker) {
-      worker.postMessage({ type: "contentMessage", data: request });
-      const responseHandler = (event) => {
-        if (event.data.type === "contentResponse") {
-          sendResponse(event.data.response);
-          worker.removeEventListener("message", responseHandler);
-        }
-      };
-      worker.addEventListener("message", responseHandler);
-      setTimeout(() => {
-        worker.removeEventListener("message", responseHandler);
-      }, 1e4);
-    } else {
-      sendResponse({ error: "No AI worker for this tab" });
-    }
-  }
-  // ===========================================================================
-  // Script Execution Helper
-  // ===========================================================================
-  executeScript(tabId, code) {
-    return new Promise((resolve, reject) => {
-      if (chrome.scripting) {
-        chrome.scripting.executeScript({
-          target: { tabId },
-          func: new Function(`return (${code})`)
-        }, (results) => {
-          var _a;
-          if (chrome.runtime.lastError) {
-            reject(new Error(chrome.runtime.lastError.message));
-          } else {
-            resolve((_a = results == null ? void 0 : results[0]) == null ? void 0 : _a.result);
-          }
-        });
-      } else {
-        chrome.tabs.executeScript(tabId, { code }, (results) => {
-          if (chrome.runtime.lastError) {
-            reject(new Error(chrome.runtime.lastError.message));
-          } else {
-            resolve(results == null ? void 0 : results[0]);
-          }
-        });
-      }
-    });
-  }
-};
-
-// src/webgpu-ai.ts
-var WebGPUAI = class {
-  constructor() {
-    this.device = null;
-    this.models = /* @__PURE__ */ new Map();
-    // ---------------------------------------------------------------------------
-    // BPE Tokenizer (byte-level, GPT-2 compatible)
-    // ---------------------------------------------------------------------------
-    this.byteEncoder = {};
-    this.byteDecoder = {};
-    this.byteEncoderInitialized = false;
-    // ---------------------------------------------------------------------------
-    // WGSL Compute Shaders
-    // ---------------------------------------------------------------------------
-    this.matmulShader = `
-    @group(0) @binding(0) var<storage, read> weights: array<f32>;
-    @group(0) @binding(1) var<storage, read> input_tokens: array<f32>;
-    @group(0) @binding(2) var<storage, read_write> output_logits: array<f32>;
-    @group(0) @binding(3) var<storage, read> params: array<u32>;
-
-    // params[0] = input_size
-    // params[1] = output_size (vocab_size)
-    // params[2] = weights_offset
-
-    @compute @workgroup_size(256)
-    fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-      let out_idx = gid.x;
-      let input_size = params[0];
-      let output_size = params[1];
-      let w_offset = params[2];
-
-      if (out_idx >= output_size) {
-        return;
-      }
-
-      var sum: f32 = 0.0;
-      for (var j: u32 = 0u; j < input_size; j = j + 1u) {
-        let w_idx = w_offset + out_idx * input_size + j;
-        if (w_idx < arrayLength(&weights)) {
-          sum = sum + weights[w_idx] * input_tokens[j];
-        }
-      }
-      output_logits[out_idx] = sum;
-    }
-  `;
-    this.softmaxShader = `
-    @group(0) @binding(0) var<storage, read_write> data: array<f32>;
-    @group(0) @binding(1) var<storage, read> size_buf: array<u32>;
-
-    @compute @workgroup_size(1)
-    fn main() {
-      let size = size_buf[0];
-
-      var max_val: f32 = data[0];
-      for (var i: u32 = 1u; i < size; i = i + 1u) {
-        if (data[i] > max_val) {
-          max_val = data[i];
-        }
-      }
-
-      var sum: f32 = 0.0;
-      for (var i: u32 = 0u; i < size; i = i + 1u) {
-        let e = exp(data[i] - max_val);
-        data[i] = e;
-        sum = sum + e;
-      }
-
-      for (var i: u32 = 0u; i < size; i = i + 1u) {
-        data[i] = data[i] / sum;
-      }
-    }
-  `;
-  }
-  async initialize() {
-    var _a, _b;
-    if (!navigator.gpu) {
-      console.warn("[Hanzo AI] WebGPU not supported in this browser");
-      return false;
-    }
-    try {
-      const adapter = await navigator.gpu.requestAdapter({
-        powerPreference: "high-performance"
-      });
-      if (!adapter) {
-        console.warn("[Hanzo AI] No GPU adapter found");
-        return false;
-      }
-      this.device = await adapter.requestDevice({
-        requiredLimits: {
-          maxStorageBufferBindingSize: ((_a = adapter.limits) == null ? void 0 : _a.maxStorageBufferBindingSize) || 134217728,
-          maxBufferSize: ((_b = adapter.limits) == null ? void 0 : _b.maxBufferSize) || 268435456
-        }
-      });
-      this.device.lost.then((info) => {
-        console.error("[Hanzo AI] GPU device lost:", info.message);
-        this.device = null;
-      });
-      console.log("[Hanzo AI] WebGPU initialized successfully");
-      const features = adapter.features;
-      console.log("[Hanzo AI] GPU Features:", Array.from(features));
-      return true;
-    } catch (error) {
-      console.error("[Hanzo AI] WebGPU initialization failed:", error);
-      return false;
-    }
-  }
-  initByteEncoder() {
-    if (this.byteEncoderInitialized) return;
-    const bs = [];
-    for (let i = 33; i <= 126; i++) bs.push(i);
-    for (let i = 161; i <= 172; i++) bs.push(i);
-    for (let i = 174; i <= 255; i++) bs.push(i);
-    const cs = bs.slice();
-    let n = 0;
-    for (let b = 0; b < 256; b++) {
-      if (!bs.includes(b)) {
-        bs.push(b);
-        cs.push(256 + n);
-        n++;
-      }
-    }
-    for (let i = 0; i < bs.length; i++) {
-      this.byteEncoder[bs[i]] = String.fromCharCode(cs[i]);
-      this.byteDecoder[String.fromCharCode(cs[i])] = bs[i];
-    }
-    this.byteEncoderInitialized = true;
-  }
-  tokenize(text, model) {
-    this.initByteEncoder();
-    if (!model.vocab.length) {
-      const tokens2 = [];
-      for (let i = 0; i < text.length; i++) {
-        tokens2.push(text.charCodeAt(i));
-      }
-      return tokens2;
-    }
-    const bytes = new TextEncoder().encode(text);
-    let word = "";
-    for (const b of bytes) {
-      word += this.byteEncoder[b] || String.fromCharCode(b);
-    }
-    const tokens = [];
-    let pos = 0;
-    while (pos < word.length) {
-      let bestLen = 0;
-      let bestIdx = -1;
-      const maxLen = Math.min(word.length - pos, 50);
-      for (let len = maxLen; len >= 1; len--) {
-        const candidate = word.substring(pos, pos + len);
-        const idx = model.vocabIndex.get(candidate);
-        if (idx !== void 0) {
-          bestLen = len;
-          bestIdx = idx;
-          break;
-        }
-      }
-      if (bestIdx !== -1) {
-        tokens.push(bestIdx);
-        pos += bestLen;
-      } else {
-        tokens.push(word.charCodeAt(pos) % Math.max(model.vocab.length, 1));
-        pos++;
-      }
-    }
-    return tokens;
-  }
-  detokenize(tokenIds, model) {
-    this.initByteEncoder();
-    if (!model.vocab.length) {
-      const arr = tokenIds instanceof Int32Array ? Array.from(tokenIds) : tokenIds;
-      return String.fromCharCode(...arr.filter((t) => t > 0 && t < 65536));
-    }
-    let byteStr = "";
-    for (const id of tokenIds) {
-      if (id >= 0 && id < model.vocab.length) {
-        byteStr += model.vocab[id];
-      }
-    }
-    const decoded = [];
-    for (const ch of byteStr) {
-      if (ch in this.byteDecoder) {
-        decoded.push(this.byteDecoder[ch]);
-      } else {
-        decoded.push(ch.charCodeAt(0) & 255);
-      }
-    }
-    return new TextDecoder().decode(new Uint8Array(decoded));
-  }
-  // ---------------------------------------------------------------------------
-  // Model Loading
-  // ---------------------------------------------------------------------------
-  async loadModel(config) {
-    if (!this.device) {
-      throw new Error("WebGPU not initialized");
-    }
-    console.log(`[Hanzo AI] Loading model: ${config.name}`);
-    const response = await fetch(config.url);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch model ${config.name}: ${response.status}`);
-    }
-    const modelData = await response.arrayBuffer();
-    const modelBuffer = this.device.createBuffer({
-      size: modelData.byteLength,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-      label: `model-${config.name}`
-    });
-    this.device.queue.writeBuffer(modelBuffer, 0, modelData);
-    let vocab = [];
-    const vocabIndex = /* @__PURE__ */ new Map();
-    if (config.vocabUrl) {
-      try {
-        const vocabResp = await fetch(config.vocabUrl);
-        if (vocabResp.ok) {
-          const vocabData = await vocabResp.json();
-          if (Array.isArray(vocabData)) {
-            vocab = vocabData;
-          } else if (typeof vocabData === "object") {
-            const entries = Object.entries(vocabData);
-            entries.sort((a, b) => a[1] - b[1]);
-            vocab = entries.map((e) => e[0]);
-          }
-          for (let i = 0; i < vocab.length; i++) {
-            vocabIndex.set(vocab[i], i);
-          }
-        }
-      } catch (e) {
-        console.warn(`[Hanzo AI] Vocabulary load failed for ${config.name}:`, e);
-      }
-    }
-    this.models.set(config.name, {
-      buffer: modelBuffer,
-      config,
-      vocab,
-      vocabIndex
-    });
-    console.log(`[Hanzo AI] Model ${config.name} loaded: ${modelData.byteLength} bytes, vocab: ${vocab.length}`);
-  }
-  // ---------------------------------------------------------------------------
-  // Inference
-  // ---------------------------------------------------------------------------
-  async runInference(modelName, input) {
-    const model = this.models.get(modelName);
-    if (!model || !this.device) {
-      throw new Error(`Model ${modelName} not loaded or GPU unavailable`);
-    }
-    const tokens = this.tokenize(input, model);
-    const vocabSize = Math.max(model.vocab.length, 256);
-    const inputSize = Math.min(tokens.length, 2048);
-    const maxTokens = model.config.maxTokens || 128;
-    const inputData = new Float32Array(inputSize);
-    for (let i = 0; i < inputSize; i++) {
-      inputData[i] = tokens[i] / vocabSize;
-    }
-    const inputBuffer = this.device.createBuffer({
-      size: inputData.byteLength,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-      label: "input"
-    });
-    this.device.queue.writeBuffer(inputBuffer, 0, inputData);
-    const outputByteSize = vocabSize * 4;
-    const outputBuffer = this.device.createBuffer({
-      size: outputByteSize,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
-      label: "output"
-    });
-    const paramsData = new Uint32Array([inputSize, vocabSize, 0]);
-    const paramsBuffer = this.device.createBuffer({
-      size: paramsData.byteLength,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-      label: "params"
-    });
-    this.device.queue.writeBuffer(paramsBuffer, 0, paramsData);
-    const readBuffer = this.device.createBuffer({
-      size: outputByteSize,
-      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-      label: "readback"
-    });
-    const matmulModule = this.device.createShaderModule({ code: this.matmulShader });
-    const matmulLayout = this.device.createBindGroupLayout({
-      entries: [
-        { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
-        { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
-        { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
-        { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } }
-      ]
-    });
-    const matmulPipeline = this.device.createComputePipeline({
-      layout: this.device.createPipelineLayout({ bindGroupLayouts: [matmulLayout] }),
-      compute: { module: matmulModule, entryPoint: "main" }
-    });
-    const matmulBindGroup = this.device.createBindGroup({
-      layout: matmulLayout,
-      entries: [
-        { binding: 0, resource: { buffer: model.buffer } },
-        { binding: 1, resource: { buffer: inputBuffer } },
-        { binding: 2, resource: { buffer: outputBuffer } },
-        { binding: 3, resource: { buffer: paramsBuffer } }
-      ]
-    });
-    const softmaxModule = this.device.createShaderModule({ code: this.softmaxShader });
-    const softmaxLayout = this.device.createBindGroupLayout({
-      entries: [
-        { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
-        { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } }
-      ]
-    });
-    const sizeBuf = this.device.createBuffer({
-      size: 4,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
-    });
-    this.device.queue.writeBuffer(sizeBuf, 0, new Uint32Array([vocabSize]));
-    const softmaxPipeline = this.device.createComputePipeline({
-      layout: this.device.createPipelineLayout({ bindGroupLayouts: [softmaxLayout] }),
-      compute: { module: softmaxModule, entryPoint: "main" }
-    });
-    const softmaxBindGroup = this.device.createBindGroup({
-      layout: softmaxLayout,
-      entries: [
-        { binding: 0, resource: { buffer: outputBuffer } },
-        { binding: 1, resource: { buffer: sizeBuf } }
-      ]
-    });
-    const generatedTokens = [];
-    const temperature = 0.7;
-    for (let step = 0; step < maxTokens; step++) {
-      const encoder = this.device.createCommandEncoder();
-      const matmulPass = encoder.beginComputePass();
-      matmulPass.setPipeline(matmulPipeline);
-      matmulPass.setBindGroup(0, matmulBindGroup);
-      matmulPass.dispatchWorkgroups(Math.ceil(vocabSize / 256));
-      matmulPass.end();
-      const softmaxPass = encoder.beginComputePass();
-      softmaxPass.setPipeline(softmaxPipeline);
-      softmaxPass.setBindGroup(0, softmaxBindGroup);
-      softmaxPass.dispatchWorkgroups(1);
-      softmaxPass.end();
-      encoder.copyBufferToBuffer(outputBuffer, 0, readBuffer, 0, outputByteSize);
-      this.device.queue.submit([encoder.finish()]);
-      await readBuffer.mapAsync(GPUMapMode.READ);
-      const probs = new Float32Array(readBuffer.getMappedRange().slice(0));
-      readBuffer.unmap();
-      const nextToken = this.sampleToken(probs, temperature);
-      generatedTokens.push(nextToken);
-      if (nextToken === 0 || nextToken === 2) break;
-      const newInput = new Float32Array([nextToken / vocabSize]);
-      this.device.queue.writeBuffer(inputBuffer, 0, newInput);
-      paramsData[0] = 1;
-      this.device.queue.writeBuffer(paramsBuffer, 0, paramsData);
-    }
-    inputBuffer.destroy();
-    outputBuffer.destroy();
-    paramsBuffer.destroy();
-    readBuffer.destroy();
-    sizeBuf.destroy();
-    return this.detokenize(generatedTokens, model);
-  }
-  sampleToken(probs, temperature) {
-    if (temperature <= 0) {
-      let maxIdx = 0;
-      let maxVal = probs[0];
-      for (let i = 1; i < probs.length; i++) {
-        if (probs[i] > maxVal) {
-          maxVal = probs[i];
-          maxIdx = i;
-        }
-      }
-      return maxIdx;
-    }
-    const scaled = new Float32Array(probs.length);
-    let sum = 0;
-    for (let i = 0; i < probs.length; i++) {
-      scaled[i] = Math.exp(Math.log(Math.max(probs[i], 1e-10)) / temperature);
-      sum += scaled[i];
-    }
-    for (let i = 0; i < scaled.length; i++) {
-      scaled[i] /= sum;
-    }
-    const r = Math.random();
-    let cumulative = 0;
-    for (let i = 0; i < scaled.length; i++) {
-      cumulative += scaled[i];
-      if (r < cumulative) return i;
-    }
-    return scaled.length - 1;
-  }
-  // ---------------------------------------------------------------------------
-  // Embedding computation (for DOM element analysis)
-  // ---------------------------------------------------------------------------
-  async computeEmbedding(modelName, text) {
-    const model = this.models.get(modelName);
-    if (!model || !this.device) {
-      throw new Error(`Model ${modelName} not loaded or GPU unavailable`);
-    }
-    const tokens = this.tokenize(text, model);
-    const inputSize = Math.min(tokens.length, 512);
-    const embeddingDim = 256;
-    const inputData = new Float32Array(inputSize);
-    for (let i = 0; i < inputSize; i++) {
-      inputData[i] = tokens[i];
-    }
-    const inputBuffer = this.device.createBuffer({
-      size: inputData.byteLength,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
-    });
-    this.device.queue.writeBuffer(inputBuffer, 0, inputData);
-    const embeddingBuffer = this.device.createBuffer({
-      size: embeddingDim * 4,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
-    });
-    const paramData = new Uint32Array([inputSize, embeddingDim, 0]);
-    const paramBuffer = this.device.createBuffer({
-      size: paramData.byteLength,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
-    });
-    this.device.queue.writeBuffer(paramBuffer, 0, paramData);
-    const shaderModule = this.device.createShaderModule({ code: this.matmulShader });
-    const layout = this.device.createBindGroupLayout({
-      entries: [
-        { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
-        { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
-        { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
-        { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } }
-      ]
-    });
-    const pipeline = this.device.createComputePipeline({
-      layout: this.device.createPipelineLayout({ bindGroupLayouts: [layout] }),
-      compute: { module: shaderModule, entryPoint: "main" }
-    });
-    const bindGroup = this.device.createBindGroup({
-      layout,
-      entries: [
-        { binding: 0, resource: { buffer: model.buffer } },
-        { binding: 1, resource: { buffer: inputBuffer } },
-        { binding: 2, resource: { buffer: embeddingBuffer } },
-        { binding: 3, resource: { buffer: paramBuffer } }
-      ]
-    });
-    const readBuffer = this.device.createBuffer({
-      size: embeddingDim * 4,
-      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-    });
-    const encoder = this.device.createCommandEncoder();
-    const pass = encoder.beginComputePass();
-    pass.setPipeline(pipeline);
-    pass.setBindGroup(0, bindGroup);
-    pass.dispatchWorkgroups(Math.ceil(embeddingDim / 256));
-    pass.end();
-    encoder.copyBufferToBuffer(embeddingBuffer, 0, readBuffer, 0, embeddingDim * 4);
-    this.device.queue.submit([encoder.finish()]);
-    await readBuffer.mapAsync(GPUMapMode.READ);
-    const embedding = new Float32Array(readBuffer.getMappedRange().slice(0));
-    readBuffer.unmap();
-    let norm = 0;
-    for (let i = 0; i < embedding.length; i++) {
-      norm += embedding[i] * embedding[i];
-    }
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-      for (let i = 0; i < embedding.length; i++) {
-        embedding[i] /= norm;
-      }
-    }
-    inputBuffer.destroy();
-    embeddingBuffer.destroy();
-    paramBuffer.destroy();
-    readBuffer.destroy();
-    return embedding;
-  }
-  // ---------------------------------------------------------------------------
-  // Status / Cleanup
-  // ---------------------------------------------------------------------------
-  getStatus() {
-    return {
-      initialized: !!this.device,
-      models: Array.from(this.models.keys())
-    };
-  }
-  async unloadModel(name) {
-    const model = this.models.get(name);
-    if (model) {
-      model.buffer.destroy();
-      this.models.delete(name);
-      console.log(`[Hanzo AI] Model ${name} unloaded`);
-    }
-  }
-  destroy() {
-    for (const [name, model] of this.models) {
-      model.buffer.destroy();
-    }
-    this.models.clear();
-    this.device = null;
-  }
-};
-
-// src/cdp-bridge.ts
-var CDPBridge = class {
-  constructor() {
-    this.sessions = /* @__PURE__ */ new Map();
-    this.messageHandlers = /* @__PURE__ */ new Map();
-    this.commandId = 0;
-    this.wsServer = null;
-    this.wsClients = /* @__PURE__ */ new Set();
-    this.setupDebuggerListener();
-  }
-  setupDebuggerListener() {
-    if (typeof chrome !== "undefined" && chrome.debugger) {
-      chrome.debugger.onEvent.addListener((source, method, params) => {
-        this.broadcastEvent(source.tabId, method, params);
-      });
-      chrome.debugger.onDetach.addListener((source, reason) => {
-        console.log(`[CDP] Detached from tab ${source.tabId}: ${reason}`);
-        if (source.tabId) {
-          this.sessions.delete(source.tabId);
-        }
-      });
-    }
-  }
-  // Attach debugger to a tab
-  async attach(tabId) {
-    if (this.sessions.has(tabId)) {
-      return true;
-    }
-    return new Promise((resolve) => {
-      const debuggee = { tabId };
-      chrome.debugger.attach(debuggee, "1.3", () => {
-        if (chrome.runtime.lastError) {
-          console.error(`[CDP] Failed to attach: ${chrome.runtime.lastError.message}`);
-          resolve(false);
-        } else {
-          this.sessions.set(tabId, {
-            tabId,
-            debuggee,
-            connected: true
-          });
-          console.log(`[CDP] Attached to tab ${tabId}`);
-          resolve(true);
-        }
-      });
-    });
-  }
-  // Detach from a tab
-  async detach(tabId) {
-    const session = this.sessions.get(tabId);
-    if (!session) return;
-    return new Promise((resolve) => {
-      chrome.debugger.detach(session.debuggee, () => {
-        this.sessions.delete(tabId);
-        resolve();
-      });
-    });
-  }
-  // Send CDP command
-  async send(tabId, method, params) {
-    const session = this.sessions.get(tabId);
-    if (!session) {
-      const attached = await this.attach(tabId);
-      if (!attached) {
-        throw new Error(`Cannot attach to tab ${tabId}`);
-      }
-    }
-    return new Promise((resolve, reject) => {
-      chrome.debugger.sendCommand(
-        { tabId },
-        method,
-        params || {},
-        (result) => {
-          if (chrome.runtime.lastError) {
-            reject(new Error(chrome.runtime.lastError.message));
-          } else {
-            resolve(result);
-          }
-        }
-      );
-    });
-  }
-  // High-level browser control methods for hanzo-mcp integration
-  async navigate(tabId, url) {
-    await this.send(tabId, "Page.navigate", { url });
-  }
-  async screenshot(tabId, options) {
-    await this.send(tabId, "Page.enable");
-    const params = {
-      format: (options == null ? void 0 : options.format) || "png"
-    };
-    if (options == null ? void 0 : options.quality) {
-      params.quality = options.quality;
-    }
-    if (options == null ? void 0 : options.fullPage) {
-      const metrics = await this.send(tabId, "Page.getLayoutMetrics");
-      params.clip = {
-        x: 0,
-        y: 0,
-        width: metrics.contentSize.width,
-        height: metrics.contentSize.height,
-        scale: 1
-      };
-      params.captureBeyondViewport = true;
-    } else if (options == null ? void 0 : options.clip) {
-      params.clip = { ...options.clip, scale: 1 };
-    }
-    const result = await this.send(tabId, "Page.captureScreenshot", params);
-    return result.data;
-  }
-  async click(tabId, x, y) {
-    await this.send(tabId, "Input.dispatchMouseEvent", {
-      type: "mousePressed",
-      x,
-      y,
-      button: "left",
-      clickCount: 1
-    });
-    await this.send(tabId, "Input.dispatchMouseEvent", {
-      type: "mouseReleased",
-      x,
-      y,
-      button: "left",
-      clickCount: 1
-    });
-  }
-  async type(tabId, text) {
-    for (const char of text) {
-      await this.send(tabId, "Input.dispatchKeyEvent", {
-        type: "keyDown",
-        text: char
-      });
-      await this.send(tabId, "Input.dispatchKeyEvent", {
-        type: "keyUp",
-        text: char
-      });
-    }
-  }
-  async evaluate(tabId, expression) {
-    var _a;
-    await this.send(tabId, "Runtime.enable");
-    const result = await this.send(tabId, "Runtime.evaluate", {
-      expression,
-      returnByValue: true
-    });
-    return (_a = result.result) == null ? void 0 : _a.value;
-  }
-  async getDocument(tabId) {
-    await this.send(tabId, "DOM.enable");
-    return this.send(tabId, "DOM.getDocument");
-  }
-  async querySelector(tabId, selector) {
-    const doc = await this.getDocument(tabId);
-    try {
-      const result = await this.send(tabId, "DOM.querySelector", {
-        nodeId: doc.root.nodeId,
-        selector
-      });
-      return result.nodeId || null;
-    } catch {
-      return null;
-    }
-  }
-  async getBoxModel(tabId, nodeId) {
-    return this.send(tabId, "DOM.getBoxModel", { nodeId });
-  }
-  async clickSelector(tabId, selector) {
-    var _a;
-    const nodeId = await this.querySelector(tabId, selector);
-    if (!nodeId) {
-      return false;
-    }
-    const box = await this.getBoxModel(tabId, nodeId);
-    if (!((_a = box == null ? void 0 : box.model) == null ? void 0 : _a.content)) {
-      return false;
-    }
-    const quad = box.model.content;
-    const x = (quad[0] + quad[2] + quad[4] + quad[6]) / 4;
-    const y = (quad[1] + quad[3] + quad[5] + quad[7]) / 4;
-    await this.click(tabId, x, y);
-    return true;
-  }
-  async fillSelector(tabId, selector, value) {
-    const nodeId = await this.querySelector(tabId, selector);
-    if (!nodeId) {
-      return false;
-    }
-    await this.send(tabId, "DOM.focus", { nodeId });
-    await this.send(tabId, "Input.dispatchKeyEvent", {
-      type: "keyDown",
-      key: "a",
-      modifiers: 2
-      // Ctrl/Cmd
-    });
-    await this.send(tabId, "Input.dispatchKeyEvent", {
-      type: "keyUp",
-      key: "a",
-      modifiers: 2
-    });
-    await this.type(tabId, value);
-    return true;
-  }
-  // WebSocket server for external connections (hanzo-mcp)
-  startWebSocketServer(port = 9223) {
-    this.connectToBridge(`ws://localhost:${port}/cdp`);
-  }
-  connectToBridge(url) {
-    try {
-      this.wsServer = new WebSocket(url);
-      this.wsServer.onopen = () => {
-        var _a;
-        console.log("[CDP] Connected to bridge server");
-        const browser = typeof navigator !== "undefined" ? navigator.userAgent.includes("Firefox") ? "firefox" : navigator.userAgent.includes("Edg/") ? "edge" : navigator.userAgent.includes("Chrome") ? "chrome" : navigator.userAgent.includes("Safari") ? "safari" : "unknown" : "unknown";
-        (_a = this.wsServer) == null ? void 0 : _a.send(JSON.stringify({
-          type: "register",
-          role: "cdp-provider",
-          browser,
-          capabilities: ["navigate", "screenshot", "click", "type", "evaluate", "takeover"]
-        }));
-      };
-      this.wsServer.onmessage = async (event) => {
-        var _a, _b;
-        try {
-          const message = JSON.parse(event.data);
-          const response = await this.handleBridgeMessage(message);
-          (_a = this.wsServer) == null ? void 0 : _a.send(JSON.stringify(response));
-        } catch (error) {
-          (_b = this.wsServer) == null ? void 0 : _b.send(JSON.stringify({
-            id: 0,
-            error: { code: -32603, message: error.message }
-          }));
-        }
-      };
-      this.wsServer.onerror = (error) => {
-        console.error("[CDP] Bridge connection error:", error);
-      };
-      this.wsServer.onclose = () => {
-        console.log("[CDP] Bridge disconnected, reconnecting in 5s...");
-        setTimeout(() => this.connectToBridge(url), 5e3);
-      };
-    } catch (error) {
-      console.error("[CDP] Failed to connect to bridge:", error);
-      setTimeout(() => this.connectToBridge(url), 5e3);
-    }
-  }
-  async handleBridgeMessage(message) {
-    const { id, method, params } = message;
-    try {
-      let result;
-      const tabId = (params == null ? void 0 : params.tabId) || await this.getActiveTabId();
-      switch (method) {
-        case "Browser.getVersion":
-          result = {
-            protocolVersion: "1.3",
-            product: "Hanzo Browser Extension",
-            userAgent: navigator.userAgent
-          };
-          break;
-        case "Target.getTargets":
-          result = await this.getTargets();
-          break;
-        case "Page.navigate":
-          this.notifyControlOverlay(tabId, "ai.control.cursor", { x: 24, y: 24 });
-          this.notifyControlOverlay(tabId, "ai.control.status", { text: `Navigating to ${params.url}` });
-          await this.navigate(tabId, params.url);
-          result = { frameId: "main" };
-          break;
-        case "Page.captureScreenshot":
-          const screenshot = await this.screenshot(tabId, params);
-          result = { data: screenshot };
-          break;
-        case "Input.dispatchMouseEvent":
-          if ((params == null ? void 0 : params.x) !== void 0 && (params == null ? void 0 : params.y) !== void 0) {
-            this.notifyControlOverlay(tabId, "ai.control.cursor", { x: params.x, y: params.y });
-          }
-          await this.send(tabId, method, params);
-          result = {};
-          break;
-        case "Input.dispatchKeyEvent":
-          await this.send(tabId, method, params);
-          result = {};
-          break;
-        case "Runtime.evaluate":
-          result = await this.send(tabId, method, params);
-          break;
-        case "DOM.getDocument":
-          result = await this.getDocument(tabId);
-          break;
-        case "DOM.querySelector":
-          const nodeId = await this.querySelector(tabId, params.selector);
-          result = { nodeId };
-          break;
-        // High-level commands for hanzo-mcp
-        case "hanzo.click":
-          this.notifyControlOverlay(tabId, "ai.control.highlight", { selector: params.selector });
-          this.notifyControlOverlay(tabId, "ai.control.status", { text: `Clicking ${params.selector}` });
-          const clicked = await this.clickSelector(tabId, params.selector);
-          result = { success: clicked };
-          break;
-        case "hanzo.fill":
-          this.notifyControlOverlay(tabId, "ai.control.highlight", { selector: params.selector });
-          this.notifyControlOverlay(tabId, "ai.control.status", { text: `Filling ${params.selector}` });
-          const filled = await this.fillSelector(tabId, params.selector, params.value);
-          result = { success: filled };
-          break;
-        case "hanzo.screenshot":
-          const screenshotData = await this.screenshot(tabId, params);
-          result = { data: screenshotData };
-          break;
-        // Control overlay management
-        case "hanzo.control.start":
-        case "hanzo.takeover.start":
-          this.notifyControlOverlay(tabId, "ai.control.start", { task: params.task || "Hanzo AI is controlling this tab" });
-          result = { success: true };
-          break;
-        case "hanzo.control.stop":
-        case "hanzo.takeover.end":
-          this.notifyControlOverlay(tabId, "ai.control.stop", {});
-          result = { success: true };
-          break;
-        case "hanzo.takeover.cursor":
-          if ((params == null ? void 0 : params.x) !== void 0 && (params == null ? void 0 : params.y) !== void 0) {
-            this.notifyControlOverlay(tabId, "ai.control.cursor", { x: params.x, y: params.y });
-          }
-          result = { success: true };
-          break;
-        default:
-          result = await this.send(tabId, method, params);
-      }
-      return { id, result };
-    } catch (error) {
-      return {
-        id,
-        error: { code: -32603, message: error.message }
-      };
-    }
-  }
-  async getActiveTabId() {
-    return new Promise((resolve, reject) => {
-      chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
-        var _a;
-        if ((_a = tabs[0]) == null ? void 0 : _a.id) {
-          resolve(tabs[0].id);
-        } else {
-          reject(new Error("No active tab"));
-        }
-      });
-    });
-  }
-  async getTargets() {
-    return new Promise((resolve) => {
-      chrome.tabs.query({}, (tabs) => {
-        const targetInfos = tabs.map((tab) => ({
-          targetId: `tab-${tab.id}`,
-          type: "page",
-          title: tab.title,
-          url: tab.url,
-          attached: this.sessions.has(tab.id),
-          browserContextId: "default"
-        }));
-        resolve({ targetInfos });
-      });
-    });
-  }
-  notifyControlOverlay(tabId, action, data) {
-    try {
-      chrome.tabs.sendMessage(tabId, { action, ...data }, () => {
-        if (chrome.runtime.lastError) {
-        }
-      });
-    } catch {
-    }
-  }
-  /** Check whether the bridge WebSocket is connected. */
-  isBridgeConnected() {
-    return this.wsServer !== null && this.wsServer.readyState === WebSocket.OPEN;
-  }
-  /** Send a config key/value to the bridge server for persistence. */
-  sendConfig(key, value) {
-    if (!this.isBridgeConnected()) return;
-    this.wsServer.send(JSON.stringify({
-      type: "config",
-      key,
-      value
-    }));
-  }
-  broadcastEvent(tabId, method, params) {
-    var _a;
-    const event = JSON.stringify({
-      type: "event",
-      tabId,
-      method,
-      params
-    });
-    if (((_a = this.wsServer) == null ? void 0 : _a.readyState) === WebSocket.OPEN) {
-      this.wsServer.send(event);
-    }
-  }
-};
-var cdpBridgeInstance = null;
-function getCDPBridge() {
-  if (!cdpBridgeInstance) {
-    cdpBridgeInstance = new CDPBridge();
-  }
-  return cdpBridgeInstance;
-}
-
-// src/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) {
-  const encoder = new TextEncoder();
-  return crypto.subtle.digest("SHA-256", encoder.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 };
-}
-function generateState() {
-  return generateRandomString(32);
-}
-var IAM_LOGIN = "https://hanzo.id";
-var IAM_API = "https://iam.hanzo.ai";
-var CLIENT_ID = "app-hanzo";
-var SCOPES = "openid profile email";
-function getRedirectUri() {
-  return "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"
-};
-async function storeTokens(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;
-  }
-  return chrome.storage.local.set(data);
-}
-async function getStoredTokens() {
-  return new Promise((resolve) => {
-    chrome.storage.local.get(
-      [STORAGE_KEYS.accessToken, STORAGE_KEYS.refreshToken, STORAGE_KEYS.expiresAt],
-      (result) => {
-        resolve({
-          accessToken: result[STORAGE_KEYS.accessToken] || null,
-          refreshToken: result[STORAGE_KEYS.refreshToken] || null,
-          expiresAt: result[STORAGE_KEYS.expiresAt] || null
-        });
-      }
-    );
-  });
-}
-async function login() {
-  const { codeVerifier, codeChallenge } = await generatePkceChallenge();
-  const state = generateState();
-  const redirectUri = getRedirectUri();
-  const authorizeUrl = new URL(`${IAM_LOGIN}/login/oauth/authorize`);
-  authorizeUrl.searchParams.set("client_id", CLIENT_ID);
-  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", SCOPES);
-  authorizeUrl.searchParams.set("state", state);
-  const callbackUrl = await openAuthTab(authorizeUrl.toString(), redirectUri);
-  const url = new URL(callbackUrl);
-  const returnedState = url.searchParams.get("state");
-  if (returnedState !== state) throw new Error("State mismatch \u2014 possible CSRF");
-  const code = url.searchParams.get("code");
-  const directToken = url.searchParams.get("access_token");
-  if (directToken) {
-    const tokens = {
-      access_token: directToken,
-      refresh_token: url.searchParams.get("refresh_token") || void 0,
-      token_type: "Bearer"
-    };
-    await storeTokens(tokens);
-  } else if (code) {
-    const tokenResponse = await fetch(`${IAM_API}/api/login/oauth/access_token`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        grant_type: "authorization_code",
-        client_id: CLIENT_ID,
-        code,
-        redirect_uri: redirectUri,
-        code_verifier: codeVerifier
-      })
-    });
-    if (!tokenResponse.ok) {
-      const errText = await tokenResponse.text();
-      throw new Error(`Token exchange failed: ${errText}`);
-    }
-    const tokens = await tokenResponse.json();
-    await storeTokens(tokens);
-  } 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();
-  if (!accessToken) throw new Error("Login succeeded but no token was stored");
-  const user = await fetchUserInfo(accessToken);
-  await chrome.storage.local.set({ [STORAGE_KEYS.user]: user });
-  return user;
-}
-function openAuthTab(authorizeUrl, redirectUriPrefix) {
-  return new Promise((resolve, reject) => {
-    let authTabId;
-    const timeout = setTimeout(() => {
-      cleanup();
-      reject(new Error("Login timed out"));
-    }, 3e5);
-    function cleanup() {
-      clearTimeout(timeout);
-      chrome.tabs.onUpdated.removeListener(onTabUpdated);
-      chrome.tabs.onRemoved.removeListener(onTabRemoved);
-    }
-    function onTabUpdated(tabId, changeInfo) {
-      if (tabId !== authTabId || !changeInfo.url) return;
-      if (changeInfo.url.startsWith(redirectUriPrefix)) {
-        const callbackUrl = changeInfo.url;
-        cleanup();
-        chrome.tabs.remove(tabId).catch(() => {
-        });
-        resolve(callbackUrl);
-      }
-    }
-    function onTabRemoved(tabId) {
-      if (tabId !== authTabId) return;
-      cleanup();
-      reject(new Error("Login cancelled"));
-    }
-    chrome.tabs.onUpdated.addListener(onTabUpdated);
-    chrome.tabs.onRemoved.addListener(onTabRemoved);
-    chrome.tabs.create({ url: authorizeUrl }, (tab) => {
-      var _a;
-      if (chrome.runtime.lastError || !(tab == null ? void 0 : tab.id)) {
-        cleanup();
-        reject(new Error(((_a = chrome.runtime.lastError) == null ? void 0 : _a.message) || "Failed to open login tab"));
-        return;
-      }
-      authTabId = tab.id;
-    });
-  });
-}
-async function logout() {
-  await chrome.storage.local.remove(Object.values(STORAGE_KEYS));
-}
-async function getValidAccessToken() {
-  const { accessToken, refreshToken, expiresAt } = await getStoredTokens();
-  if (!accessToken) return null;
-  if (expiresAt && Date.now() < expiresAt - 6e4) {
-    return accessToken;
-  }
-  if (refreshToken) {
-    try {
-      const refreshed = await refreshAccessToken(refreshToken);
-      return refreshed;
-    } catch {
-      await logout();
-      return null;
-    }
-  }
-  return accessToken;
-}
-async function refreshAccessToken(refreshToken) {
-  const response = await fetch(`${IAM_API}/api/login/oauth/access_token`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      grant_type: "refresh_token",
-      client_id: CLIENT_ID,
-      refresh_token: refreshToken
-    })
-  });
-  if (!response.ok) throw new Error("Token refresh failed");
-  const tokens = await response.json();
-  await storeTokens(tokens);
-  return tokens.access_token;
-}
-async function fetchUserInfo(accessToken) {
-  const response = await fetch(`${IAM_API}/api/userinfo`, {
-    headers: { Authorization: `Bearer ${accessToken}` }
-  });
-  if (!response.ok) throw new Error("Failed to fetch user info");
-  return response.json();
-}
-async function getUserInfo() {
-  return new Promise((resolve) => {
-    chrome.storage.local.get([STORAGE_KEYS.user], (result) => {
-      resolve(result[STORAGE_KEYS.user] || null);
-    });
-  });
-}
-async function isAuthenticated() {
-  const { accessToken } = await getStoredTokens();
-  return !!accessToken;
-}
-async function getAuthStatus() {
-  const [authenticated, user] = await Promise.all([
-    isAuthenticated(),
-    getUserInfo()
-  ]);
-  return { authenticated, user };
-}
-
-// src/chat-client.ts
-var API_BASE = "https://api.hanzo.ai";
-async function listModels(token) {
-  const response = await fetch(`${API_BASE}/v1/models`, {
-    headers: { Authorization: `Bearer ${token}` }
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to list models: ${response.status}`);
-  }
-  const data = await response.json();
-  return data.data || data.models || data || [];
-}
-async function chatCompletion(token, options) {
-  var _a, _b, _c;
-  const response = await fetch(`${API_BASE}/v1/chat/completions`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify(options)
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`Chat API error ${response.status}: ${text}`);
-  }
-  const data = await response.json();
-  return ((_c = (_b = (_a = data.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.message) == null ? void 0 : _c.content) || "";
-}
-
-// src/background.ts
-var browserControl = new BrowserControl();
-var webgpuAI = new WebGPUAI();
-var cdpBridge = getCDPBridge();
-var zapState = {
-  connected: false,
-  mcps: [],
-  extensionId: `hanzo-ext-${Date.now().toString(36)}`
-};
-var controlSession = {
-  active: false,
-  tabId: null,
-  task: null,
-  startedAt: null
-};
-var DEFAULT_ZAP_PORTS = [9999, 9998, 9997, 9996, 9995];
-var DEFAULT_MCP_PORT = 3001;
-var DEFAULT_CDP_PORT = 9223;
-var ZAP_RECONNECT_DELAY = 3e3;
-var ZAP_DISCOVERY_TIMEOUT = 2e3;
-var DEFAULT_RAG_TOP_K = 5;
-async function getPortConfig() {
-  return new Promise((resolve) => {
-    chrome.storage.local.get(["zapPorts", "mcpPort", "cdpPort"], (result) => {
-      resolve({
-        zapPorts: result.zapPorts || DEFAULT_ZAP_PORTS,
-        mcpPort: result.mcpPort || DEFAULT_MCP_PORT,
-        cdpPort: result.cdpPort || DEFAULT_CDP_PORT
-      });
-    });
-  });
-}
-async function getRagConfig() {
-  return new Promise((resolve) => {
-    chrome.storage.local.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
-      });
-    });
-  });
-}
-var zapConnections = /* @__PURE__ */ new Map();
-var ZAP_MAGIC = new Uint8Array([90, 65, 80, 1]);
-var MSG_HANDSHAKE = 1;
-var MSG_HANDSHAKE_OK = 2;
-var MSG_REQUEST = 16;
-var MSG_RESPONSE = 17;
-var MSG_PING = 254;
-var MSG_PONG = 255;
-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 decodeZapMessage(buf) {
-  if (buf.byteLength < 9) return null;
-  const view = new DataView(buf);
-  const magic = new Uint8Array(buf, 0, 4);
-  if (magic[0] !== 90 || magic[1] !== 65 || magic[2] !== 80 || magic[3] !== 1) {
-    return null;
-  }
-  const type = view.getUint8(4);
-  const length = view.getUint32(5, false);
-  const decoder = new TextDecoder();
-  const json = decoder.decode(new Uint8Array(buf, 9, length));
-  return { type, payload: JSON.parse(json) };
-}
-function probeZapServer(port) {
-  return new Promise((resolve) => {
-    const url = `ws://localhost:${port}`;
-    const ws2 = new WebSocket(url);
-    const timer = setTimeout(() => {
-      ws2.close();
-      resolve(null);
-    }, ZAP_DISCOVERY_TIMEOUT);
-    ws2.binaryType = "arraybuffer";
-    ws2.onopen = () => {
-      clearTimeout(timer);
-      ws2.send(encodeZapMessage(MSG_HANDSHAKE, {
-        clientId: zapState.extensionId,
-        clientType: "browser_extension",
-        browser: detectBrowser(),
-        version: chrome.runtime.getManifest().version,
-        capabilities: ["tabs", "navigate", "screenshot", "evaluate", "cookies", "storage"]
-      }));
-      const hsTimer = setTimeout(() => {
-        ws2.close();
-        resolve(null);
-      }, ZAP_DISCOVERY_TIMEOUT);
-      ws2.onmessage = (ev) => {
-        clearTimeout(hsTimer);
-        ws2.close();
-        resolve(url);
-      };
-    };
-    ws2.onerror = () => {
-      clearTimeout(timer);
-      resolve(null);
-    };
-  });
-}
-async function connectZap(url) {
-  return new Promise((resolve) => {
-    const ws2 = new WebSocket(url);
-    ws2.binaryType = "arraybuffer";
-    const connTimer = setTimeout(() => {
-      ws2.close();
-      resolve(null);
-    }, 1e4);
-    ws2.onopen = () => {
-      ws2.send(encodeZapMessage(MSG_HANDSHAKE, {
-        clientId: zapState.extensionId,
-        clientType: "browser_extension",
-        browser: detectBrowser(),
-        version: chrome.runtime.getManifest().version,
-        capabilities: ["tabs", "navigate", "screenshot", "evaluate", "cookies", "storage"]
-      }));
-    };
-    ws2.onmessage = (ev) => {
-      let msg = null;
-      if (ev.data instanceof ArrayBuffer) {
-        msg = decodeZapMessage(ev.data);
-      }
-      if (!msg && typeof ev.data === "string") {
-        try {
-          const json = JSON.parse(ev.data);
-          handleMCPMessage(json);
-          return;
-        } catch {
-          return;
-        }
-      }
-      if (!msg) return;
-      switch (msg.type) {
-        case MSG_HANDSHAKE_OK: {
-          clearTimeout(connTimer);
-          const info = msg.payload;
-          const mcpId = info.serverId || `mcp-${Date.now().toString(36)}`;
-          zapConnections.set(mcpId, ws2);
-          zapState.connected = true;
-          zapState.mcps.push({
-            id: mcpId,
-            name: info.name || `MCP@${url}`,
-            url,
-            tools: (info.tools || []).map((t) => t.name)
-          });
-          console.log(`[Hanzo/ZAP] Connected to ${info.name || url} (${(info.tools || []).length} tools)`);
-          resolve(mcpId);
-          break;
-        }
-        case MSG_RESPONSE: {
-          const { id, result, error } = msg.payload;
-          const pending = pendingRequests.get(id);
-          if (pending) {
-            pendingRequests.delete(id);
-            if (error) pending.reject(new Error(error.message || error));
-            else pending.resolve(result);
-          }
-          break;
-        }
-        case MSG_PING:
-          ws2.send(encodeZapMessage(MSG_PONG, {}));
-          break;
-      }
-    };
-    ws2.onclose = () => {
-      for (const [id, conn] of zapConnections) {
-        if (conn === ws2) {
-          zapConnections.delete(id);
-          zapState.mcps = zapState.mcps.filter((m) => m.id !== id);
-          break;
-        }
-      }
-      zapState.connected = zapConnections.size > 0;
-      console.log(`[Hanzo/ZAP] Disconnected from ${url}, reconnecting in ${ZAP_RECONNECT_DELAY}ms...`);
-      setTimeout(() => connectZap(url), ZAP_RECONNECT_DELAY);
-    };
-    ws2.onerror = () => {
-      clearTimeout(connTimer);
-      resolve(null);
-    };
-  });
-}
-var pendingRequests = /* @__PURE__ */ new Map();
-var requestIdCounter = 0;
-function zapRequest(mcpId, method, params = {}) {
-  const ws2 = zapConnections.get(mcpId);
-  if (!ws2 || ws2.readyState !== WebSocket.OPEN) {
-    return Promise.reject(new Error(`MCP ${mcpId} not connected`));
-  }
-  const id = `req-${++requestIdCounter}`;
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      pendingRequests.delete(id);
-      reject(new Error(`ZAP request timeout: ${method}`));
-    }, 3e4);
-    pendingRequests.set(id, {
-      resolve: (r) => {
-        clearTimeout(timer);
-        resolve(r);
-      },
-      reject: (e) => {
-        clearTimeout(timer);
-        reject(e);
-      }
-    });
-    ws2.send(encodeZapMessage(MSG_REQUEST, { id, method, params }));
-  });
-}
-async function zapCallTool(name, args = {}, targetMcpId) {
-  if (targetMcpId) {
-    return zapRequest(targetMcpId, "tools/call", { name, arguments: args });
-  }
-  for (const mcp of zapState.mcps) {
-    if (mcp.tools.includes(name)) {
-      return zapRequest(mcp.id, "tools/call", { name, arguments: args });
-    }
-  }
-  throw new Error(`Tool not found on any ZAP-connected MCP: ${name}`);
-}
-function hasZapTool(name) {
-  return zapState.mcps.some((mcp) => mcp.tools.includes(name));
-}
-function normalizeRagSnippets(raw) {
-  if (!raw) return [];
-  const candidates = [];
-  if (Array.isArray(raw)) candidates.push(...raw);
-  if (Array.isArray(raw == null ? void 0 : raw.snippets)) candidates.push(...raw.snippets);
-  if (Array.isArray(raw == null ? void 0 : raw.documents)) candidates.push(...raw.documents);
-  if (Array.isArray(raw == null ? void 0 : raw.items)) candidates.push(...raw.items);
-  if (Array.isArray(raw == null ? void 0 : raw.results)) candidates.push(...raw.results);
-  if (Array.isArray(raw == null ? void 0 : raw.memories)) candidates.push(...raw.memories);
-  if (Array.isArray(raw == null ? void 0 : raw.matches)) candidates.push(...raw.matches);
-  if (!candidates.length && typeof (raw == null ? void 0 : raw.content) === "string") {
-    candidates.push({ content: raw.content, source: raw.source || "memory" });
-  }
-  const snippets = candidates.map((item) => {
-    const content = String(
-      (item == null ? void 0 : item.content) ?? (item == null ? void 0 : item.text) ?? (item == null ? void 0 : item.snippet) ?? (item == null ? void 0 : item.body) ?? (item == null ? void 0 : item.value) ?? ""
-    ).trim();
-    if (!content) return null;
-    return {
-      content,
-      title: (item == null ? void 0 : item.title) ? String(item.title) : void 0,
-      source: (item == null ? void 0 : item.source) ? String(item.source) : void 0,
-      score: typeof (item == null ? void 0 : item.score) === "number" ? item.score : void 0,
-      url: (item == null ? void 0 : item.url) ? String(item.url) : void 0
-    };
-  }).filter((item) => !!item);
-  return snippets.slice(0, 20);
-}
-async function queryRagFromZap(params) {
-  if (!params.useZapMemory || !zapState.connected || !hasZapTool("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("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"
-  }));
-}
-async function discoverZapServers() {
-  console.log("[Hanzo/ZAP] Discovering MCP servers...");
-  const { zapPorts } = await getPortConfig();
-  const results = await Promise.all(zapPorts.map((p) => probeZapServer(p)));
-  const available = results.filter(Boolean);
-  if (available.length === 0) {
-    console.log("[Hanzo/ZAP] No servers found, retrying in 10s...");
-    setTimeout(discoverZapServers, 1e4);
-    return;
-  }
-  console.log(`[Hanzo/ZAP] Found ${available.length} server(s): ${available.join(", ")}`);
-  await Promise.all(available.map((url) => connectZap(url)));
-}
-function detectBrowser() {
-  if (typeof navigator === "undefined") return "unknown";
-  const ua = navigator.userAgent;
-  if (ua.includes("Firefox")) return "firefox";
-  if (ua.includes("Edg/")) return "edge";
-  if (ua.includes("Chrome")) return "chrome";
-  if (ua.includes("Safari")) return "safari";
-  return "unknown";
-}
-function sendControlMessageToTab(tabId, message) {
-  chrome.tabs.sendMessage(tabId, message, () => {
-    if (chrome.runtime.lastError) {
-    }
-  });
-}
-function sendMessageToTab(tabId, message) {
-  return new Promise((resolve, reject) => {
-    chrome.tabs.sendMessage(tabId, message, (response) => {
-      if (chrome.runtime.lastError) {
-        reject(new Error(chrome.runtime.lastError.message || "Failed to contact page content script"));
-        return;
-      }
-      resolve(response);
-    });
-  });
-}
-function getActiveTabId() {
-  return new Promise((resolve) => {
-    chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
-      var _a;
-      resolve(((_a = tabs[0]) == null ? void 0 : _a.id) ?? null);
-    });
-  });
-}
-async function resolveControlTabId(tabId) {
-  if (typeof tabId === "number") return tabId;
-  if (controlSession.active && controlSession.tabId !== null) return controlSession.tabId;
-  return getActiveTabId();
-}
-async function startControlSession(tabId, task) {
-  if (controlSession.active && controlSession.tabId !== null && controlSession.tabId !== tabId) {
-    sendControlMessageToTab(controlSession.tabId, { action: "ai.control.stop" });
-  }
-  controlSession.active = true;
-  controlSession.tabId = tabId;
-  controlSession.task = task || "AI is controlling this page";
-  controlSession.startedAt = Date.now();
-  sendControlMessageToTab(tabId, {
-    action: "ai.control.start",
-    task: controlSession.task
-  });
-}
-async function stopControlSession() {
-  if (controlSession.active && controlSession.tabId !== null) {
-    sendControlMessageToTab(controlSession.tabId, { action: "ai.control.stop" });
-  }
-  controlSession.active = false;
-  controlSession.tabId = null;
-  controlSession.task = null;
-  controlSession.startedAt = null;
-}
-chrome.runtime.onInstalled.addListener(async () => {
-  console.log("[Hanzo] Extension installed, initializing...");
-  const gpuAvailable = await webgpuAI.initialize();
-  if (gpuAvailable) {
-    console.log("[Hanzo] WebGPU available, loading local models...");
-    try {
-      await webgpuAI.loadModel({
-        name: "hanzo-browser-control",
-        url: chrome.runtime.getURL("models/browser-control-4bit.bin"),
-        quantization: "4bit",
-        maxTokens: 512
-      });
-    } catch (error) {
-      console.error("[Hanzo] Failed to load local model:", error);
-    }
-  }
-});
-chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
-  handleMessage(request, sender, sendResponse);
-  return true;
-});
-async function handleMessage(request, sender, sendResponse) {
-  var _a, _b;
-  switch (request.action) {
-    // --- ZAP Protocol actions ---
-    case "zap.status":
-      sendResponse({ success: true, zap: zapState });
-      break;
-    case "zap.discover":
-      discoverZapServers().then(() => sendResponse({ success: true, mcps: zapState.mcps }));
-      break;
-    case "zap.connect":
-      try {
-        const mcpId = await connectZap(request.url);
-        sendResponse({ success: !!mcpId, mcpId });
-      } catch (e) {
-        sendResponse({ success: false, error: e.message });
-      }
-      break;
-    case "zap.callTool":
-      try {
-        const result = await zapCallTool(request.name, request.args, request.mcpId);
-        sendResponse({ success: true, result });
-      } catch (e) {
-        sendResponse({ success: false, error: e.message });
-      }
-      break;
-    case "zap.listTools": {
-      const tools = zapState.mcps.flatMap((m) => m.tools.map((t) => ({ name: t, mcpId: m.id, mcpName: m.name })));
-      sendResponse({ success: true, tools });
-      break;
-    }
-    // --- Local AI ---
-    case "runLocalAI":
-      try {
-        const result = await webgpuAI.runInference(request.model || "hanzo-browser-control", request.prompt);
-        sendResponse({ success: true, result });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "checkWebGPU": {
-      try {
-        if (!navigator.gpu) {
-          sendResponse({ available: false });
-          break;
-        }
-        const adapter = await navigator.gpu.requestAdapter();
-        sendResponse({
-          available: !!adapter,
-          adapter: (adapter == null ? void 0 : adapter.name) || "Unknown GPU",
-          models: webgpuAI.getStatus().models
-        });
-      } catch {
-        sendResponse({ available: false });
-      }
-      break;
-    }
-    case "listAgents":
-      sendResponse({ success: true, agents: browserControl.getAgents() });
-      break;
-    case "stopAgent":
-      sendResponse({ success: browserControl.stopAgent(request.agentId) });
-      break;
-    case "launchAIWorker":
-      try {
-        const targetTabId = request.tabId || ((_a = sender.tab) == null ? void 0 : _a.id);
-        if (!targetTabId) {
-          sendResponse({ success: false, error: "No target tab found" });
-          break;
-        }
-        const agentId = await browserControl.launchAIWorker(targetTabId, request.model || "browser-control");
-        sendResponse({ success: true, agentId });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    // --- Tab Filesystem ---
-    case "readTabFS":
-      try {
-        const content = await browserControl.readTab(request.path);
-        sendResponse({ success: true, content });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "writeTabFS":
-      try {
-        await browserControl.writeTab(request.path, request.content);
-        sendResponse({ success: true });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "listTabFS":
-      const tabs = await browserControl.listTabs();
-      sendResponse({ success: true, tabs });
-      break;
-    // --- CDP bridge commands ---
-    case "cdp.attach":
-      try {
-        const attached = await cdpBridge.attach(request.tabId);
-        sendResponse({ success: attached });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "cdp.detach":
-      try {
-        await cdpBridge.detach(request.tabId);
-        sendResponse({ success: true });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "cdp.send":
-      try {
-        const result = await cdpBridge.send(request.tabId, request.method, request.params);
-        sendResponse({ success: true, result });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "cdp.screenshot":
-      try {
-        const screenshot = await cdpBridge.screenshot(request.tabId, request.options);
-        sendResponse({ success: true, data: screenshot });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "cdp.click":
-      try {
-        const clicked = await cdpBridge.clickSelector(request.tabId, request.selector);
-        sendResponse({ success: clicked });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "cdp.fill":
-      try {
-        const filled = await cdpBridge.fillSelector(request.tabId, request.selector, request.value);
-        sendResponse({ success: filled });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "cdp.navigate":
-      try {
-        await cdpBridge.navigate(request.tabId, request.url);
-        sendResponse({ success: true });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "cdp.evaluate":
-      try {
-        const evalResult = await cdpBridge.evaluate(request.tabId, request.expression);
-        sendResponse({ success: true, result: evalResult });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    // --- AI Control Overlay ---
-    case "ai.control.start": {
-      const tabId = await resolveControlTabId(request.tabId);
-      if (tabId === null) {
-        sendResponse({ success: false, error: "No target tab found" });
-        break;
-      }
-      await startControlSession(tabId, request.task);
-      sendResponse({
-        success: true,
-        session: {
-          active: controlSession.active,
-          tabId: controlSession.tabId,
-          task: controlSession.task,
-          startedAt: controlSession.startedAt
-        }
-      });
-      break;
-    }
-    case "ai.control.stop": {
-      await stopControlSession();
-      sendResponse({ success: true });
-      break;
-    }
-    case "ai.control.cursor":
-    case "ai.control.highlight":
-    case "ai.control.status": {
-      const tabId = await resolveControlTabId(request.tabId);
-      if (tabId === null) {
-        sendResponse({ success: false, error: "No target tab found" });
-        break;
-      }
-      if (controlSession.active && controlSession.tabId !== null && tabId !== controlSession.tabId) {
-        sendResponse({
-          success: false,
-          error: `Control locked to tab ${controlSession.tabId}`
-        });
-        break;
-      }
-      sendControlMessageToTab(tabId, request);
-      sendResponse({ success: true, tabId });
-      break;
-    }
-    case "ai.control.cancel":
-      await stopControlSession();
-      if (zapState.connected) {
-        for (const [, conn] of zapConnections) {
-          if (conn.readyState === WebSocket.OPEN) {
-            conn.send(encodeZapMessage(MSG_REQUEST, {
-              id: `cancel-${++requestIdCounter}`,
-              method: "notifications/controlCancelled",
-              params: {}
-            }));
-          }
-        }
-      }
-      sendResponse({ success: true });
-      break;
-    // --- In-page overlay (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 : ((_b = sender.tab) == null ? void 0 : _b.id) ?? await getActiveTabId();
-        if (tabId === null) {
-          sendResponse({ success: false, error: "No target tab found" });
-          break;
-        }
-        const response = await sendMessageToTab(tabId, { action: request.action });
-        sendResponse({ success: true, tabId, ...response || {} });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    }
-    // --- Auth (Hanzo IAM OAuth2 + PKCE) ---
-    case "auth.login":
-      try {
-        const user = await login();
-        sendResponse({ success: true, user });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "auth.logout":
-      try {
-        await logout();
-        sendResponse({ success: true });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "auth.status":
-      try {
-        const status = await getAuthStatus();
-        sendResponse({ success: true, ...status });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "auth.getToken":
-      try {
-        const token = await getValidAccessToken();
-        sendResponse({ success: !!token, token });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "rag.query":
-      try {
-        const config = await getRagConfig();
-        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)) : DEFAULT_RAG_TOP_K,
-          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);
-        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 (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    // --- Cloud Chat ---
-    case "chat.listModels":
-      try {
-        const token = await getValidAccessToken();
-        if (!token) {
-          sendResponse({ success: false, error: "Not authenticated" });
-          break;
-        }
-        const models = await listModels(token);
-        sendResponse({ success: true, models });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    case "chat.complete":
-      try {
-        const token = await getValidAccessToken();
-        if (!token) {
-          sendResponse({ success: false, error: "Not authenticated" });
-          break;
-        }
-        const model = String(request.model || "gpt-4o");
-        const messagesInput = Array.isArray(request.messages) ? request.messages : [];
-        const messages = messagesInput.filter((msg) => msg && typeof msg.content === "string" && typeof msg.role === "string").map((msg) => ({
-          role: msg.role === "system" || msg.role === "assistant" ? msg.role : "user",
-          content: String(msg.content)
-        })).slice(-24);
-        if (!messages.length) {
-          sendResponse({ success: false, error: "messages are required" });
-          break;
-        }
-        const content = await chatCompletion(token, {
-          model,
-          messages,
-          temperature: typeof request.temperature === "number" ? request.temperature : void 0,
-          max_tokens: typeof request.max_tokens === "number" ? request.max_tokens : void 0
-        });
-        sendResponse({ success: true, content });
-      } catch (error) {
-        sendResponse({ success: false, error: error.message });
-      }
-      break;
-    // --- Bridge status ---
-    case "bridge.status": {
-      const bridgeConnected = cdpBridge.isBridgeConnected();
-      sendResponse({
-        success: true,
-        connected: bridgeConnected,
-        browsers: bridgeConnected ? [detectBrowser()] : []
-      });
-      break;
-    }
-    // --- Config persistence ---
-    case "config.save": {
-      const { key, value } = request;
-      cdpBridge.sendConfig(key, value);
-      sendResponse({ success: true });
-      break;
-    }
-    // --- Takeover messages (forwarded from CDP bridge to content script) ---
-    case "hanzo.takeover.start": {
-      const takeoverTabId = await resolveControlTabId(request.tabId);
-      if (takeoverTabId === null) {
-        sendResponse({ success: false, error: "No target tab found" });
-        break;
-      }
-      await startControlSession(takeoverTabId, request.task);
-      sendResponse({ success: true });
-      break;
-    }
-    case "hanzo.takeover.end": {
-      await stopControlSession();
-      sendResponse({ success: true });
-      break;
-    }
-    case "hanzo.takeover.cursor": {
-      const cursorTabId = await resolveControlTabId(request.tabId);
-      if (cursorTabId !== null) {
-        sendControlMessageToTab(cursorTabId, {
-          action: "ai.control.cursor",
-          x: request.x,
-          y: request.y
-        });
-      }
-      sendResponse({ success: true });
-      break;
-    }
-    // --- Content script element selection (routed from content script) ---
-    case "elementSelected":
-      if (zapState.connected) {
-        for (const [, conn] of zapConnections) {
-          if (conn.readyState === WebSocket.OPEN) {
-            conn.send(encodeZapMessage(MSG_REQUEST, {
-              id: `evt-${++requestIdCounter}`,
-              method: "notifications/elementSelected",
-              params: request.data
-            }));
-          }
-        }
-      }
-      if (ws && ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify(request.data));
-      }
-      sendResponse({ success: true });
-      break;
-  }
-}
-var ws = null;
-async function connectToMCP() {
-  const { mcpPort } = await getPortConfig();
-  ws = new WebSocket(`ws://localhost:${mcpPort}/browser-extension`);
-  ws.onopen = () => {
-    console.log("[Hanzo] Connected to legacy MCP server");
-  };
-  ws.onmessage = (event) => {
-    const data = JSON.parse(event.data);
-    handleMCPMessage(data);
-  };
-  ws.onerror = () => {
-  };
-  ws.onclose = () => {
-    setTimeout(connectToMCP, 5e3);
-  };
-}
-function handleMCPMessage(data) {
-  switch (data.type) {
-    case "browserControl":
-      chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
-        var _a;
-        if ((_a = tabs[0]) == null ? void 0 : _a.id) {
-          browserControl.launchAIWorker(tabs[0].id, data.model);
-        }
-      });
-      break;
-  }
-}
-if (chrome.sidePanel) {
-  chrome.sidePanel.setOptions({ path: "sidebar.html", enabled: true });
-}
-chrome.tabs.onRemoved.addListener((tabId) => {
-  if (controlSession.active && controlSession.tabId === tabId) {
-    void stopControlSession();
-  }
-});
-discoverZapServers();
-connectToMCP();
-getPortConfig().then(({ cdpPort }) => {
-  try {
-    cdpBridge.startWebSocketServer(cdpPort);
-    console.log(`[Hanzo] CDP bridge connecting to ws://localhost:${cdpPort}/cdp`);
-  } catch (e) {
-    console.error("[Hanzo] Failed to start CDP bridge:", e);
-  }
-});
-export {
-  browserControl,
-  webgpuAI,
-  zapCallTool,
-  zapState
-};