@vforsh/argus 0.3.0 → 0.4.0

package/dist/extension/dist/background/service-worker.js

@@ -1,10 +1,125 @@
+// src/background/frame-table.ts
+var applyFrameTreeSnapshot = (table, sessionId, node) => {
+  if (!node?.frame?.id) {
+    return;
+  }
+  const nextFrameIds = /* @__PURE__ */ new Set();
+  mergeFrameTree(table, sessionId, node, nextFrameIds);
+  for (const [frameId, frame] of table.frames.entries()) {
+    if (frame.sessionId === sessionId && !nextFrameIds.has(frameId)) {
+      table.frames.delete(frameId);
+    }
+  }
+};
+var mergeFrameTree = (table, sessionId, node, nextFrameIds) => {
+  if (!node?.frame?.id) {
+    return;
+  }
+  const frameId = node.frame.id;
+  nextFrameIds.add(frameId);
+  table.frames.set(frameId, toFrameRecord(node.frame, sessionId));
+  if (!node.frame.parentId && !sessionId) {
+    table.topFrameId = frameId;
+  }
+  for (const child of node.childFrames ?? []) {
+    mergeFrameTree(table, sessionId, child, nextFrameIds);
+  }
+};
+var applyFrameEvent = (table, sessionId, method, params) => {
+  if (method === "Page.frameNavigated" && params) {
+    const frame = params.frame;
+    if (!frame?.id) {
+      return false;
+    }
+    table.frames.set(frame.id, toFrameRecord(frame, sessionId));
+    if (!frame.parentId && !sessionId && frame.url) {
+      table.url = frame.url;
+      table.topFrameId = frame.id;
+    }
+    return true;
+  }
+  if (method === "Page.frameAttached" && params) {
+    const frame = params;
+    if (!frame.frameId) {
+      return false;
+    }
+    const existing = table.frames.get(frame.frameId);
+    table.frames.set(frame.frameId, {
+      frameId: frame.frameId,
+      parentFrameId: frame.parentFrameId ?? table.topFrameId,
+      url: existing?.url ?? "",
+      title: existing?.title ?? null,
+      sessionId: existing?.sessionId ?? sessionId
+    });
+    return true;
+  }
+  if (method === "Page.frameDetached" && params) {
+    const frame = params;
+    if (!frame.frameId) {
+      return false;
+    }
+    return table.frames.delete(frame.frameId);
+  }
+  return false;
+};
+var dropSessionFrames = (table, sessionId) => {
+  let removed = false;
+  for (const [frameId, frame] of table.frames.entries()) {
+    if (frame.sessionId === sessionId) {
+      table.frames.delete(frameId);
+      removed = true;
+    }
+  }
+  return removed;
+};
+var serializeFrameTable = (table) => {
+  const frames = [...table.frames.values()].sort((a, b) => a.frameId.localeCompare(b.frameId));
+  return JSON.stringify({ topFrameId: table.topFrameId, frames });
+};
+var toFrameRecord = (frame, sessionId) => ({
+  frameId: frame.id,
+  parentFrameId: frame.parentId ?? null,
+  url: frame.url ?? "",
+  title: frame.name ?? null,
+  sessionId
+});
+
+// src/background/tab-cookies.ts
+var readTabCookies = async (tabId, query = {}) => {
+  const storeId = await findCookieStoreId(tabId);
+  const cookies = await chrome.cookies.getAll({
+    domain: query.domain,
+    storeId: storeId ?? void 0,
+    url: query.domain ? void 0 : query.url
+  });
+  return cookies.map((cookie) => ({
+    name: cookie.name,
+    value: cookie.value,
+    domain: cookie.domain,
+    path: cookie.path,
+    secure: cookie.secure,
+    httpOnly: cookie.httpOnly,
+    session: cookie.session,
+    expires: typeof cookie.expirationDate === "number" ? cookie.expirationDate : null,
+    sameSite: cookie.sameSite ?? null
+  }));
+};
+var findCookieStoreId = async (tabId) => {
+  const stores = await chrome.cookies.getAllCookieStores();
+  const store = stores.find((candidate) => candidate.tabIds.includes(tabId));
+  return store?.id ?? null;
+};
+
 // src/background/debugger-manager.ts
 var FRAME_TREE_SYNC_DELAY_MS = 150;
 var DebuggerManager = class {
   attached = /* @__PURE__ */ new Map();
   eventHandlers = /* @__PURE__ */ new Set();
   detachHandlers = /* @__PURE__ */ new Set();
+  framesChangedHandlers = /* @__PURE__ */ new Set();
   frameTreeSyncTimers = /* @__PURE__ */ new Map();
+  /** Last published frame table per tab; publishes that change nothing are suppressed. */
+  lastPublishedFrames = /* @__PURE__ */ new Map();
   constructor() {
     chrome.debugger.onEvent.addListener((debuggee, method, params) => {
       this.handleCdpEvent(debuggee, method, params);
@@ -27,6 +142,13 @@ var DebuggerManager = class {
       this.detachHandlers.delete(handler);
     };
   }
+  /** Subscribe to authoritative frame-table changes (deduplicated; see class doc). */
+  onFramesChanged(handler) {
+    this.framesChangedHandlers.add(handler);
+    return () => {
+      this.framesChangedHandlers.delete(handler);
+    };
+  }
   emitEvent(tabId, method, params, sessionId) {
     for (const handler of this.eventHandlers) {
       handler(tabId, method, params, { sessionId });
@@ -59,6 +181,7 @@ var DebuggerManager = class {
     this.attached.set(tabId, target);
     await this.configureAutoAttach(tabId);
     await this.refreshFrameTree(tabId, null);
+    this.lastPublishedFrames.set(tabId, serializeFrameTable(target));
     return target;
   }
   async detach(tabId) {
@@ -69,6 +192,7 @@ var DebuggerManager = class {
     } catch {
     }
     this.attached.delete(tabId);
+    this.lastPublishedFrames.delete(tabId);
   }
   async sendCommand(tabId, method, params, sessionId) {
     const target = this.getRequiredTarget(tabId);
@@ -100,29 +224,35 @@ var DebuggerManager = class {
     }
     return [...target.frames.values()];
   }
+  /** Current authoritative frame table for a tab, in `frame_snapshot` payload shape. */
+  getFrameSnapshot(tabId) {
+    return {
+      topFrameId: this.attached.get(tabId)?.topFrameId ?? null,
+      frames: this.getFrames(tabId)
+    };
+  }
   /**
-   * Read cookies from the attached tab's cookie store so extension-mode auth export can keep
-   * sibling subdomain session cookies such as `auth.example.com`.
+   * Re-read `Page.getFrameTree` for the root and every child session, then return the
+   * fresh table. Serves `frame_snapshot_request { refresh: true }` (bootstrap and target
+   * recovery on the watcher side). Marks the result as published — the caller ships it
+   * as the request's reply, so no push should follow for the same state.
    */
+  async resyncFrames(tabId) {
+    const target = this.getRequiredTarget(tabId);
+    await this.refreshFrameTree(tabId, null);
+    for (const sessionId of target.childSessions.keys()) {
+      try {
+        await this.refreshFrameTree(tabId, sessionId);
+      } catch {
+      }
+    }
+    this.lastPublishedFrames.set(tabId, serializeFrameTable(target));
+    return this.getFrameSnapshot(tabId);
+  }
+  /** Read cookies from the attached tab's cookie store (see tab-cookies.ts). */
   async getCookies(tabId, query = {}) {
     this.getRequiredTarget(tabId);
-    const storeId = await this.findCookieStoreId(tabId);
-    const cookies = await chrome.cookies.getAll({
-      domain: query.domain,
-      storeId: storeId ?? void 0,
-      url: query.domain ? void 0 : query.url
-    });
-    return cookies.map((cookie) => ({
-      name: cookie.name,
-      value: cookie.value,
-      domain: cookie.domain,
-      path: cookie.path,
-      secure: cookie.secure,
-      httpOnly: cookie.httpOnly,
-      session: cookie.session,
-      expires: typeof cookie.expirationDate === "number" ? cookie.expirationDate : null,
-      sameSite: cookie.sameSite ?? null
-    }));
+    return readTabCookies(tabId, query);
   }
   async configureAutoAttach(tabId, sessionId) {
     await this.sendCommand(
@@ -167,11 +297,6 @@ var DebuggerManager = class {
     }
     return { tabId: target.tabId, sessionId };
   }
-  async findCookieStoreId(tabId) {
-    const stores = await chrome.cookies.getAllCookieStores();
-    const store = stores.find((candidate) => candidate.tabIds.includes(tabId));
-    return store?.id ?? null;
-  }
   handleCdpEvent(debuggee, method, params) {
     const tabId = debuggee.tabId;
     if (!tabId || !this.attached.has(tabId)) return;
@@ -210,6 +335,7 @@ var DebuggerManager = class {
       await this.configureAutoAttach(tabId, record.sessionId);
       await this.enableChildSessionDomains(tabId, record.sessionId);
       await this.refreshFrameTree(tabId, record.sessionId);
+      this.emitFramesChangedIfNeeded(tabId, "child_attached");
     } catch (error) {
       console.warn("[DebuggerManager] Failed to bootstrap child target:", error);
     }
@@ -229,106 +355,34 @@ var DebuggerManager = class {
   }
   async refreshFrameTree(tabId, sessionId) {
     const result = await this.sendCommand(tabId, "Page.getFrameTree", void 0, sessionId);
-    this.replaceFrameTreeSnapshot(tabId, sessionId, result.frameTree);
-  }
-  /**
-   * Each `Page.getFrameTree` result is a full snapshot for that session, so merge the refreshed
-   * nodes and then prune frames from the same session that no longer exist after reload.
-   */
-  replaceFrameTreeSnapshot(tabId, sessionId, node) {
-    if (!node?.frame?.id) {
-      return;
-    }
-    const target = this.attached.get(tabId);
-    if (!target) {
-      return;
-    }
-    const nextFrameIds = /* @__PURE__ */ new Set();
-    this.mergeFrameTree(tabId, sessionId, node, nextFrameIds);
-    this.pruneMissingSessionFrames(tabId, sessionId, nextFrameIds);
-  }
-  mergeFrameTree(tabId, sessionId, node, nextFrameIds) {
-    if (!node?.frame?.id) {
-      return;
-    }
     const target = this.attached.get(tabId);
     if (!target) {
       return;
     }
-    const frameId = node.frame.id;
-    nextFrameIds.add(frameId);
-    target.frames.set(frameId, this.toFrameRecord(node.frame, sessionId));
-    if (!node.frame.parentId && !sessionId) {
-      target.topFrameId = frameId;
-    }
-    this.emitEvent(
-      tabId,
-      "Page.frameNavigated",
-      {
-        frame: {
-          id: frameId,
-          parentId: node.frame.parentId ?? null,
-          url: node.frame.url ?? "",
-          name: node.frame.name ?? null
-        }
-      },
-      sessionId
-    );
-    for (const child of node.childFrames ?? []) {
-      this.mergeFrameTree(tabId, sessionId, child, nextFrameIds);
-    }
+    applyFrameTreeSnapshot(target, sessionId, result.frameTree);
   }
-  pruneMissingSessionFrames(tabId, sessionId, nextFrameIds) {
+  updateStateFromEvent(tabId, sessionId, method, params) {
     const target = this.attached.get(tabId);
     if (!target) {
       return;
     }
-    for (const [frameId, frame] of target.frames.entries()) {
-      if (frame.sessionId !== sessionId || nextFrameIds.has(frameId)) {
-        continue;
-      }
-      target.frames.delete(frameId);
-      this.emitEvent(tabId, "Page.frameDetached", { frameId }, sessionId);
+    if (applyFrameEvent(target, sessionId, method, params)) {
+      this.lastPublishedFrames.set(tabId, serializeFrameTable(target));
     }
   }
-  updateStateFromEvent(tabId, sessionId, method, params) {
+  /** Publish the tab's frame table through onFramesChanged, unless it matches the last publish. */
+  emitFramesChangedIfNeeded(tabId, reason) {
     const target = this.attached.get(tabId);
     if (!target) {
       return;
     }
-    if (method === "Page.frameNavigated" && params) {
-      const frame = params.frame;
-      if (!frame?.id) {
-        return;
-      }
-      target.frames.set(frame.id, this.toFrameRecord(frame, sessionId));
-      if (!frame.parentId && !sessionId && frame.url) {
-        target.url = frame.url;
-        target.topFrameId = frame.id;
-      }
-      return;
-    }
-    if (method === "Page.frameAttached" && params) {
-      const frame = params;
-      if (!frame.frameId) {
-        return;
-      }
-      const existing = target.frames.get(frame.frameId);
-      target.frames.set(frame.frameId, {
-        frameId: frame.frameId,
-        parentFrameId: frame.parentFrameId ?? target.topFrameId,
-        url: existing?.url ?? "",
-        title: existing?.title ?? null,
-        sessionId: existing?.sessionId ?? sessionId
-      });
+    const serialized = serializeFrameTable(target);
+    if (this.lastPublishedFrames.get(tabId) === serialized) {
       return;
     }
-    if (method === "Page.frameDetached" && params) {
-      const frame = params;
-      if (!frame.frameId) {
-        return;
-      }
-      target.frames.delete(frame.frameId);
+    this.lastPublishedFrames.set(tabId, serialized);
+    for (const handler of this.framesChangedHandlers) {
+      handler(tabId, reason);
     }
   }
   /**
@@ -346,7 +400,9 @@ var DebuggerManager = class {
     }
     const timer = setTimeout(() => {
       this.frameTreeSyncTimers.delete(key);
-      void this.refreshFrameTree(tabId, sessionId).catch((error) => {
+      void this.refreshFrameTree(tabId, sessionId).then(() => {
+        this.emitFramesChangedIfNeeded(tabId, "navigation_resync");
+      }).catch((error) => {
         console.warn("[DebuggerManager] Failed to refresh frame tree after navigation:", error);
       });
     }, FRAME_TREE_SYNC_DELAY_MS);
@@ -370,15 +426,6 @@ var DebuggerManager = class {
       this.frameTreeSyncTimers.delete(key);
     }
   }
-  toFrameRecord(frame, sessionId) {
-    return {
-      frameId: frame.id,
-      parentFrameId: frame.parentId ?? null,
-      url: frame.url ?? "",
-      title: frame.name ?? null,
-      sessionId
-    };
-  }
   handleDetach(tabId, sessionId, reason) {
     const target = this.attached.get(tabId);
     if (!target) {
@@ -391,6 +438,7 @@ var DebuggerManager = class {
     }
     this.clearAllFrameTreeSync(tabId);
     this.attached.delete(tabId);
+    this.lastPublishedFrames.delete(tabId);
     this.emitDetach(tabId, reason);
   }
   dropChildSession(tabId, sessionId) {
@@ -399,12 +447,8 @@ var DebuggerManager = class {
       return;
     }
     target.childSessions.delete(sessionId);
-    for (const [frameId, frame] of target.frames.entries()) {
-      if (frame.sessionId !== sessionId) {
-        continue;
-      }
-      target.frames.delete(frameId);
-      this.emitEvent(tabId, "Page.frameDetached", { frameId }, sessionId);
+    if (dropSessionFrames(target, sessionId)) {
+      this.emitFramesChangedIfNeeded(tabId, "child_detached");
     }
   }
 };
@@ -424,7 +468,6 @@ var BridgeClient = class {
   port = null;
   hostName;
   messageHandlers = /* @__PURE__ */ new Set();
-  connectHandler = null;
   disconnectHandler = null;
   reconnectAttempts = 0;
   maxReconnectAttempts = 5;
@@ -441,12 +484,6 @@ var BridgeClient = class {
   onMessage(handler) {
     this.messageHandlers.add(handler);
   }
-  /**
-   * Set handler for successful connection.
-   */
-  onConnect(handler) {
-    this.connectHandler = handler;
-  }
   /**
    * Set handler for disconnection.
    */
@@ -480,9 +517,6 @@ var BridgeClient = class {
       });
       console.log("[BridgeClient] Connected to", this.hostName);
       this.reconnectAttempts = 0;
-      if (this.connectHandler) {
-        this.connectHandler();
-      }
       return true;
     } catch (err) {
       console.error("[BridgeClient] Failed to connect:", err);
@@ -542,37 +576,13 @@ var BridgeClient = class {
   }
 };
 
-// src/background/tab-list.ts
-var listBrowserTabs = async (debuggerManager2, filter, options = {}) => {
-  const chromeTabs = await chrome.tabs.query({});
-  const attachedTargets = debuggerManager2.listAttached();
-  const attachedTabIds = new Set(attachedTargets.map((target) => target.tabId));
-  let tabs = chromeTabs.filter((tab) => tab.id !== void 0 && tab.url !== void 0).filter((tab) => !tab.url.startsWith("chrome://") && !tab.url.startsWith("chrome-extension://")).map((tab) => ({
-    tabId: tab.id,
-    url: tab.url,
-    title: tab.title ?? "",
-    faviconUrl: tab.favIconUrl,
-    attached: attachedTabIds.has(tab.id),
-    watcherId: options.getWatcherIdForTab?.(tab.id) ?? void 0
-  }));
-  if (filter?.url) {
-    const urlFilter = filter.url.toLowerCase();
-    tabs = tabs.filter((tab) => tab.url.toLowerCase().includes(urlFilter));
-  }
-  if (filter?.title) {
-    const titleFilter = filter.title.toLowerCase();
-    tabs = tabs.filter((tab) => tab.title.toLowerCase().includes(titleFilter));
-  }
-  tabs.sort((left, right) => Number(right.attached) - Number(left.attached));
-  return tabs;
-};
-
 // src/background/cdp-proxy.ts
 var CdpProxy = class {
   debuggerManager;
   bridgeClient;
   removeDebuggerEventForwarding = null;
   removeDebuggerDetachForwarding = null;
+  removeFramesChangedForwarding = null;
   constructor(debuggerManager2, bridgeClient) {
     this.debuggerManager = debuggerManager2;
     this.bridgeClient = bridgeClient;
@@ -599,19 +609,31 @@ var CdpProxy = class {
         reason
       });
     });
+    this.removeFramesChangedForwarding = this.debuggerManager.onFramesChanged((tabId, reason) => {
+      this.bridgeClient.send({
+        type: "frame_snapshot",
+        tabId,
+        reason,
+        ...this.debuggerManager.getFrameSnapshot(tabId)
+      });
+    });
   }
   dispose() {
     this.removeDebuggerEventForwarding?.();
     this.removeDebuggerEventForwarding = null;
     this.removeDebuggerDetachForwarding?.();
     this.removeDebuggerDetachForwarding = null;
+    this.removeFramesChangedForwarding?.();
+    this.removeFramesChangedForwarding = null;
   }
   /**
    * Handle messages from the bridge.
    */
   setupMessageHandling() {
     this.bridgeClient.onMessage((message) => {
-      this.handleMessage(message);
+      void this.handleMessage(message).catch((error) => {
+        console.error("[CdpProxy] Failed to handle bridge message:", error);
+      });
     });
   }
   /**
@@ -619,9 +641,6 @@ var CdpProxy = class {
    */
   async handleMessage(message) {
     switch (message.type) {
-      case "attach_tab":
-        await this.handleAttachTab(message);
-        break;
       case "detach_tab":
         await this.handleDetachTab(message);
         break;
@@ -631,8 +650,8 @@ var CdpProxy = class {
       case "cookie_query":
         await this.handleCookieQuery(message);
         break;
-      case "enable_domain":
-        await this.handleEnableDomain(message);
+      case "frame_snapshot_request":
+        await this.handleFrameSnapshotRequest(message);
         break;
       case "host_info":
       case "host_ready":
@@ -643,11 +662,11 @@ var CdpProxy = class {
     }
   }
   /**
-   * Attach to a tab.
+   * Attach to a tab (driven by the popup; the host never requests attachment).
    */
-  async handleAttachTab(message) {
+  async attachTab(tabId) {
     try {
-      const target = await this.debuggerManager.attach(message.tabId);
+      const target = await this.debuggerManager.attach(tabId);
       this.bridgeClient.send({
         type: "tab_attached",
         tabId: target.tabId,
@@ -661,9 +680,10 @@ var CdpProxy = class {
       console.error("[CdpProxy] Failed to attach:", err);
       this.bridgeClient.send({
         type: "tab_detached",
-        tabId: message.tabId,
+        tabId,
         reason: err instanceof Error ? err.message : "attach_failed"
       });
+      throw err;
     }
   }
   /**
@@ -693,6 +713,26 @@ var CdpProxy = class {
       });
     }
   }
+  /**
+   * Answer a watcher pull for the frame table. With `refresh` the table is re-read from
+   * Chrome first; either way the reply is the full current table, so applying it is
+   * idempotent on the watcher side.
+   */
+  async handleFrameSnapshotRequest(message) {
+    let snapshot;
+    try {
+      snapshot = message.refresh ? await this.debuggerManager.resyncFrames(message.tabId) : this.debuggerManager.getFrameSnapshot(message.tabId);
+    } catch {
+      snapshot = this.debuggerManager.getFrameSnapshot(message.tabId);
+    }
+    this.bridgeClient.send({
+      type: "frame_snapshot",
+      tabId: message.tabId,
+      reason: "requested",
+      requestId: message.requestId,
+      ...snapshot
+    });
+  }
   /**
    * Query browser cookies from the attached tab's cookie store.
    */
@@ -717,22 +757,6 @@ var CdpProxy = class {
       });
     }
   }
-  /**
-   * Enable a CDP domain for a tab.
-   */
-  async handleEnableDomain(message) {
-    try {
-      await this.debuggerManager.enableDomain(message.tabId, message.domain);
-    } catch (err) {
-      console.error("[CdpProxy] Failed to enable domain:", err);
-    }
-  }
-  /**
-   * Manually attach to a tab (called from popup).
-   */
-  async attachTab(tabId) {
-    await this.handleAttachTab({ type: "attach_tab", tabId });
-  }
   /**
    * Manually detach from a tab (called from popup).
    */
@@ -744,18 +768,60 @@ var CdpProxy = class {
     });
     await this.debuggerManager.detach(tabId);
   }
-  /**
-   * Get list of tabs for popup UI.
-   */
-  async getTabsForPopup() {
-    return await listBrowserTabs(this.debuggerManager);
-  }
 };
 
 // src/background/native-hosts.ts
 var BRIDGE_HOST_NAME = "com.vforsh.argus.bridge";
 var CONTROL_HOST_NAME = "com.vforsh.argus.control";
 
+// src/background/latch.ts
+var createLatch = () => {
+  let open = false;
+  let waiters = [];
+  return {
+    get isOpen() {
+      return open;
+    },
+    wait: (timeoutMs, timeoutMessage) => {
+      if (open) {
+        return Promise.resolve();
+      }
+      return new Promise((resolve, reject) => {
+        const onOpen = () => {
+          clearTimeout(timer);
+          resolve();
+        };
+        const timer = setTimeout(() => {
+          waiters = waiters.filter((waiter) => waiter !== onOpen);
+          reject(new Error(timeoutMessage));
+        }, timeoutMs);
+        waiters.push(onOpen);
+      });
+    },
+    signal: () => {
+      open = true;
+      const pending = waiters;
+      waiters = [];
+      for (const waiter of pending) {
+        waiter();
+      }
+    }
+  };
+};
+
+// ../argus-core/dist/protocol/native-messaging.js
+var NATIVE_MESSAGING_PROTOCOL_VERSION = 2;
+
+// src/background/protocol-handshake.ts
+var checkHostProtocol = (message) => {
+  const hostVersion = message.protocolVersion;
+  if (hostVersion === NATIVE_MESSAGING_PROTOCOL_VERSION) {
+    return null;
+  }
+  const reported = hostVersion == null ? "none (predates the handshake)" : String(hostVersion);
+  return `Argus native host speaks native-messaging protocol ${reported}, extension expects ${NATIVE_MESSAGING_PROTOCOL_VERSION}. Update argus (npm i -g @vforsh/argus) and reload the extension.`;
+};
+
 // src/background/tab-bridge-session.ts
 var TabBridgeSession = class {
   tabId;
@@ -766,10 +832,10 @@ var TabBridgeSession = class {
   targetInfo = null;
   desiredWatcherId;
   lastMessageAt = null;
-  ready = false;
-  readyWaiters = [];
-  watcherInfoWaiters = [];
+  hostReady = createLatch();
+  watcherInfoReceived = createLatch();
   disposed = false;
+  protocolMismatch = null;
   constructor(tabId, debuggerManager2, events = {}, options = {}) {
     this.tabId = tabId;
     this.events = events;
@@ -799,27 +865,10 @@ var TabBridgeSession = class {
     if (!sent) {
       throw new Error(`Failed to initialize watcher for tab ${this.tabId}`);
     }
-    await this.waitUntilReady();
-    await this.waitForWatcherInfo();
+    await this.awaitLatch(this.hostReady, "did not become ready");
+    await this.awaitLatch(this.watcherInfoReceived, "did not report watcher info");
     await this.cdpProxy.attachTab(this.tabId);
   }
-  async waitUntilReady(timeoutMs = 3e3) {
-    this.assertOpen();
-    if (this.ready) {
-      return;
-    }
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.readyWaiters = this.readyWaiters.filter((waiter) => waiter !== onReady);
-        reject(new Error(`Native host session for tab ${this.tabId} did not become ready`));
-      }, timeoutMs);
-      const onReady = () => {
-        clearTimeout(timer);
-        resolve();
-      };
-      this.readyWaiters.push(onReady);
-    });
-  }
   async detach() {
     if (this.disposed) {
       return;
@@ -861,27 +910,22 @@ var TabBridgeSession = class {
   getLastMessageAt() {
     return this.lastMessageAt;
   }
-  async waitForWatcherInfo(timeoutMs = 3e3) {
+  async awaitLatch(latch, failure, timeoutMs = 3e3) {
     this.assertOpen();
-    if (this.watcherInfo) {
-      return;
-    }
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.watcherInfoWaiters = this.watcherInfoWaiters.filter((waiter) => waiter !== onWatcherInfo);
-        reject(new Error(`Native host session for tab ${this.tabId} did not report watcher info`));
-      }, timeoutMs);
-      const onWatcherInfo = () => {
-        clearTimeout(timer);
-        resolve();
-      };
-      this.watcherInfoWaiters.push(onWatcherInfo);
-    });
+    await latch.wait(timeoutMs, `Native host session for tab ${this.tabId} ${failure}`);
   }
   handleMessage(message) {
     this.lastMessageAt = Date.now();
     switch (message.type) {
-      case "host_info":
+      case "host_info": {
+        const mismatch = checkHostProtocol(message);
+        if (mismatch) {
+          console.error(`[TabBridgeSession] ${mismatch}`);
+          this.protocolMismatch = mismatch;
+          this.dispose();
+          this.events.onDisconnect?.();
+          return;
+        }
         this.watcherInfo = {
           watcherId: message.watcherId,
           watcherHost: message.watcherHost,
@@ -889,10 +933,11 @@ var TabBridgeSession = class {
           pid: message.pid
         };
         this.events.onWatcherInfo?.(this.watcherInfo);
-        this.resolveWatcherInfoWaiters();
+        this.watcherInfoReceived.signal();
         return;
+      }
       case "host_ready":
-        this.resolveReadyWaiters();
+        this.hostReady.signal();
         return;
       case "target_info":
         this.targetInfo = {
@@ -905,28 +950,52 @@ var TabBridgeSession = class {
         this.events.onTargetInfo?.(this.targetInfo);
     }
   }
-  resolveReadyWaiters() {
-    this.ready = true;
-    const waiters = this.readyWaiters;
-    this.readyWaiters = [];
-    for (const waiter of waiters) {
-      waiter();
-    }
-  }
-  resolveWatcherInfoWaiters() {
-    const waiters = this.watcherInfoWaiters;
-    this.watcherInfoWaiters = [];
-    for (const waiter of waiters) {
-      waiter();
-    }
-  }
   assertOpen() {
+    if (this.protocolMismatch) {
+      throw new Error(this.protocolMismatch);
+    }
     if (this.disposed) {
       throw new Error(`Native host session for tab ${this.tabId} is already closed`);
     }
   }
 };
 
+// src/background/tab-list.ts
+var listBrowserTabs = async (debuggerManager2, filter, options = {}) => {
+  const chromeTabs = await chrome.tabs.query({});
+  const attachedTargets = debuggerManager2.listAttached();
+  const attachedTabIds = new Set(attachedTargets.map((target) => target.tabId));
+  let tabs = chromeTabs.filter((tab) => tab.id !== void 0 && tab.url !== void 0).filter((tab) => !tab.url.startsWith("chrome://") && !tab.url.startsWith("chrome-extension://")).map((tab) => ({
+    tabId: tab.id,
+    url: tab.url,
+    title: tab.title ?? "",
+    faviconUrl: tab.favIconUrl,
+    attached: attachedTabIds.has(tab.id),
+    watcherId: options.getWatcherIdForTab?.(tab.id) ?? void 0
+  }));
+  if (filter?.url) {
+    const urlFilter = filter.url.toLowerCase();
+    tabs = tabs.filter((tab) => tab.url.toLowerCase().includes(urlFilter));
+  }
+  if (filter?.title) {
+    const titleFilter = filter.title.toLowerCase();
+    tabs = tabs.filter((tab) => tab.title.toLowerCase().includes(titleFilter));
+  }
+  tabs.sort((left, right) => Number(right.attached) - Number(left.attached));
+  return tabs;
+};
+
+// ../argus-core/dist/errorMessage.js
+var formatError = (error) => {
+  if (!error) {
+    return "unknown error";
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+
 // src/background/control-bridge-session.ts
 var ControlBridgeSession = class {
   bridgeClient;
@@ -972,7 +1041,13 @@ var ControlBridgeSession = class {
   async handleMessage(message) {
     this.lastMessageAt = Date.now();
     switch (message.type) {
-      case "host_info":
+      case "host_info": {
+        const mismatch = checkHostProtocol(message);
+        if (mismatch) {
+          console.error(`[ControlBridgeSession] ${mismatch}`);
+          this.bridgeClient.disconnect();
+          return;
+        }
         this.watcherInfo = {
           watcherId: message.watcherId,
           watcherHost: message.watcherHost,
@@ -981,6 +1056,7 @@ var ControlBridgeSession = class {
         };
         this.events.onWatcherInfo?.(this.watcherInfo);
         return;
+      }
       case "attach_tab_watcher":
         await this.handleTabAction(message.requestId, () => this.events.onAttachTabWatcher?.(message.tabId, { watcherId: message.watcherId }));
         return;
@@ -1010,7 +1086,7 @@ var ControlBridgeSession = class {
         type: "tab_action_response",
         requestId,
         ok: false,
-        error: { message: error instanceof Error ? error.message : String(error) }
+        error: { message: formatError(error) }
       });
     }
   }
@@ -1054,6 +1130,79 @@ var ControlBridgeSession = class {
   }
 };
 
+// src/background/page-keyed-store.ts
+var readStorageValue = async (storageArea, key) => new Promise((resolve, reject) => {
+  storageArea.get(key, (items) => {
+    const error = chrome.runtime.lastError;
+    if (error) {
+      reject(new Error(error.message));
+      return;
+    }
+    resolve(items[key]);
+  });
+});
+var writeStorageValue = async (storageArea, items) => new Promise((resolve, reject) => {
+  storageArea.set(items, () => {
+    const error = chrome.runtime.lastError;
+    if (error) {
+      reject(new Error(error.message));
+      return;
+    }
+    resolve();
+  });
+});
+var normalizeOptionalText = (value) => {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+};
+var sortByUpdatedAtDesc = (left, right) => right.updatedAt - left.updatedAt;
+var createChromeStorePersistence = (storageKey, sanitize, storageArea = chrome.storage.local) => ({
+  load: async () => sanitize(await readStorageValue(storageArea, storageKey)),
+  save: async (entries) => {
+    await writeStorageValue(storageArea, { [storageKey]: entries });
+  }
+});
+var PageKeyedStore = class {
+  constructor(persistence, maxEntries, label) {
+    this.persistence = persistence;
+    this.maxEntries = maxEntries;
+    this.label = label;
+  }
+  entries = [];
+  loadPromise = null;
+  saveChain = Promise.resolve();
+  /** Load on first use; later calls await the same load. */
+  async ensureLoaded() {
+    if (!this.loadPromise) {
+      this.loadPromise = this.persistence.load().then((entries) => {
+        this.entries = entries.slice(0, this.maxEntries);
+      }).catch((error) => {
+        console.error(`[${this.label}] Failed to load history:`, error);
+        this.entries = [];
+      });
+    }
+    await this.loadPromise;
+  }
+  /** Persist the current entries, serialized behind any in-flight save. */
+  async persist() {
+    this.saveChain = this.saveChain.catch(() => void 0).then(() => this.persistence.save(this.entries)).catch((error) => {
+      console.error(`[${this.label}] Failed to save history:`, error);
+    });
+    await this.saveChain;
+  }
+  /** Move an entry to the front, replacing any entry with the same page key. */
+  upsert(entry) {
+    this.entries = [entry, ...this.entries.filter((candidate) => candidate.pageKey !== entry.pageKey)].slice(0, this.maxEntries);
+  }
+  /** Find the entry for a page key. */
+  findByPageKey(pageKey) {
+    return this.entries.find((entry) => entry.pageKey === pageKey) ?? null;
+  }
+};
+
 // src/background/target-selection-history.ts
 var DEFAULT_STORAGE_KEY = "targetSelectionHistory";
 var DEFAULT_MAX_ENTRIES = 20;
@@ -1079,55 +1228,23 @@ var matchRememberedIframeTarget = (entry, targets) => {
   }
   return pickSingleTargetMatch(iframeTargets, (target) => normalizeTargetTitle(target.title) === rememberedIframe.title);
 };
-var TargetSelectionHistoryStore = class {
-  persistence;
-  maxEntries;
-  entries = [];
-  loadPromise = null;
-  saveChain = Promise.resolve();
+var TargetSelectionHistoryStore = class extends PageKeyedStore {
   constructor(persistence = createChromeStoragePersistence(), options = {}) {
-    this.persistence = persistence;
-    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    super(persistence, options.maxEntries ?? DEFAULT_MAX_ENTRIES, "TargetSelectionHistoryStore");
   }
   async getByPageUrl(pageUrl) {
     await this.ensureLoaded();
-    const pageKey = normalizeSelectionPageKey(pageUrl);
-    return this.entries.find((entry) => entry.pageKey === pageKey) ?? null;
+    return this.findByPageKey(normalizeSelectionPageKey(pageUrl));
   }
   async remember(pageUrl, target) {
     await this.ensureLoaded();
     const entry = buildRememberedSelection(pageUrl, target);
-    this.entries = [entry, ...this.entries.filter((candidate) => candidate.pageKey !== entry.pageKey)].slice(0, this.maxEntries);
+    this.upsert(entry);
     await this.persist();
     return entry;
   }
-  async ensureLoaded() {
-    if (!this.loadPromise) {
-      this.loadPromise = this.persistence.load().then((entries) => {
-        this.entries = sanitizeRememberedSelections(entries).slice(0, this.maxEntries);
-      }).catch((error) => {
-        console.error("[TargetSelectionHistoryStore] Failed to load history:", error);
-        this.entries = [];
-      });
-    }
-    await this.loadPromise;
-  }
-  async persist() {
-    this.saveChain = this.saveChain.catch(() => void 0).then(() => this.persistence.save(this.entries)).catch((error) => {
-      console.error("[TargetSelectionHistoryStore] Failed to save history:", error);
-    });
-    await this.saveChain;
-  }
 };
-var createChromeStoragePersistence = (storageArea = chrome.storage.local, storageKey = DEFAULT_STORAGE_KEY) => ({
-  load: async () => {
-    const stored = await readStorageValue(storageArea, storageKey);
-    return sanitizeRememberedSelections(Array.isArray(stored) ? stored : []);
-  },
-  save: async (entries) => {
-    await writeStorageValue(storageArea, { [storageKey]: entries });
-  }
-});
+var createChromeStoragePersistence = (storageArea = chrome.storage.local, storageKey = DEFAULT_STORAGE_KEY) => createChromeStorePersistence(storageKey, (value) => sanitizeRememberedSelections(Array.isArray(value) ? value : []), storageArea);
 var buildRememberedSelection = (pageUrl, target) => {
   const base = {
     pageKey: normalizeSelectionPageKey(pageUrl),
@@ -1190,56 +1307,25 @@ var sanitizeRememberedSelection = (entry) => {
   };
 };
 function normalizeTargetUrl(url) {
-  return normalizeOptionalText(url);
+  return normalizeOptionalText2(url);
 }
 function normalizeTargetTitle(title) {
-  return normalizeOptionalText(title);
+  return normalizeOptionalText2(title);
 }
-function normalizeOptionalText(value) {
+function normalizeOptionalText2(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
-var sortByUpdatedAtDesc = (left, right) => right.updatedAt - left.updatedAt;
-var readStorageValue = async (storageArea, key) => {
-  return await new Promise((resolve, reject) => {
-    storageArea.get(key, (items) => {
-      const error = chrome.runtime.lastError;
-      if (error) {
-        reject(new Error(error.message));
-        return;
-      }
-      resolve(items[key]);
-    });
-  });
-};
-var writeStorageValue = async (storageArea, items) => {
-  await new Promise((resolve, reject) => {
-    storageArea.set(items, () => {
-      const error = chrome.runtime.lastError;
-      if (error) {
-        reject(new Error(error.message));
-        return;
-      }
-      resolve();
-    });
-  });
-};
 
 // src/background/target-visibility-history.ts
 var DEFAULT_STORAGE_KEY2 = "hiddenTargetHistory";
 var DEFAULT_MAX_PAGE_ENTRIES = 20;
-var TargetVisibilityHistoryStore = class {
-  persistence;
-  maxPageEntries;
-  entries = [];
-  loadPromise = null;
-  saveChain = Promise.resolve();
+var TargetVisibilityHistoryStore = class extends PageKeyedStore {
   constructor(persistence = createChromeStoragePersistence2(), options = {}) {
-    this.persistence = persistence;
-    this.maxPageEntries = options.maxPageEntries ?? DEFAULT_MAX_PAGE_ENTRIES;
+    super(persistence, options.maxPageEntries ?? DEFAULT_MAX_PAGE_ENTRIES, "TargetVisibilityHistoryStore");
   }
   async getHiddenTargets(pageUrl) {
     await this.ensureLoaded();
-    return [...this.findEntry(pageUrl)?.targets ?? []];
+    return [...this.findByPageKey(normalizeSelectionPageKey(pageUrl))?.targets ?? []];
   }
   async hide(pageUrl, target) {
     await this.ensureLoaded();
@@ -1248,10 +1334,10 @@ var TargetVisibilityHistoryStore = class {
       return null;
     }
     const pageKey = normalizeSelectionPageKey(pageUrl);
-    const existing = this.findEntry(pageUrl);
+    const existing = this.findByPageKey(normalizeSelectionPageKey(pageUrl));
     const targets = uniqueHiddenTargets([hiddenTarget, ...existing?.targets ?? []]);
     const entry = { pageKey, pageUrl, updatedAt: Date.now(), targets };
-    this.upsertEntry(entry);
+    this.upsert(entry);
     await this.persist();
     return entry;
   }
@@ -1261,7 +1347,7 @@ var TargetVisibilityHistoryStore = class {
     if (!hiddenTarget) {
       return;
     }
-    const existing = this.findEntry(pageUrl);
+    const existing = this.findByPageKey(normalizeSelectionPageKey(pageUrl));
     if (!existing) {
       return;
     }
@@ -1274,44 +1360,8 @@ var TargetVisibilityHistoryStore = class {
     this.entries = this.entries.map((entry) => entry.pageKey === existing.pageKey ? { ...entry, targets, updatedAt: Date.now() } : entry);
     await this.persist();
   }
-  async isHidden(pageUrl, target) {
-    const hiddenTargets = await this.getHiddenTargets(pageUrl);
-    return hiddenTargets.some((hiddenTarget) => matchesHiddenTarget(hiddenTarget, target));
-  }
-  findEntry(pageUrl) {
-    const pageKey = normalizeSelectionPageKey(pageUrl);
-    return this.entries.find((entry) => entry.pageKey === pageKey) ?? null;
-  }
-  upsertEntry(entry) {
-    this.entries = [entry, ...this.entries.filter((candidate) => candidate.pageKey !== entry.pageKey)].slice(0, this.maxPageEntries);
-  }
-  async ensureLoaded() {
-    if (!this.loadPromise) {
-      this.loadPromise = this.persistence.load().then((entries) => {
-        this.entries = sanitizeHiddenTargetEntries(entries).slice(0, this.maxPageEntries);
-      }).catch((error) => {
-        console.error("[TargetVisibilityHistoryStore] Failed to load history:", error);
-        this.entries = [];
-      });
-    }
-    await this.loadPromise;
-  }
-  async persist() {
-    this.saveChain = this.saveChain.catch(() => void 0).then(() => this.persistence.save(this.entries)).catch((error) => {
-      console.error("[TargetVisibilityHistoryStore] Failed to save history:", error);
-    });
-    await this.saveChain;
-  }
 };
-var createChromeStoragePersistence2 = (storageArea = chrome.storage.local, storageKey = DEFAULT_STORAGE_KEY2) => ({
-  load: async () => {
-    const stored = await readStorageValue2(storageArea, storageKey);
-    return sanitizeHiddenTargetEntries(Array.isArray(stored) ? stored : []);
-  },
-  save: async (entries) => {
-    await writeStorageValue2(storageArea, { [storageKey]: entries });
-  }
-});
+var createChromeStoragePersistence2 = (storageArea = chrome.storage.local, storageKey = DEFAULT_STORAGE_KEY2) => createChromeStorePersistence(storageKey, (value) => sanitizeHiddenTargetEntries(Array.isArray(value) ? value : []), storageArea);
 function matchesHiddenTarget(hiddenTarget, target) {
   if (target.type !== "iframe") {
     return false;
@@ -1323,8 +1373,8 @@ function toHiddenTarget(target) {
   if (target.type !== "iframe") {
     return null;
   }
-  const url = normalizeOptionalText2(target.url);
-  const title = normalizeOptionalText2(target.title);
+  const url = normalizeOptionalText(target.url);
+  const title = normalizeOptionalText(target.title);
   if (!url && !title) {
     return null;
   }
@@ -1346,7 +1396,7 @@ function isSameHiddenTarget(left, right) {
   return left.title === right.title;
 }
 function sanitizeHiddenTargetEntries(entries) {
-  return entries.map(sanitizeHiddenTargetEntry).filter((entry) => entry !== null).sort(sortByUpdatedAtDesc2);
+  return entries.map(sanitizeHiddenTargetEntry).filter((entry) => entry !== null).sort(sortByUpdatedAtDesc);
 }
 function sanitizeHiddenTargetEntry(entry) {
   const candidate = entry;
@@ -1369,41 +1419,13 @@ function sanitizeHiddenTarget(target) {
   if (candidate?.type !== "iframe") {
     return null;
   }
-  const url = normalizeOptionalText2(typeof candidate.url === "string" ? candidate.url : null);
-  const title = normalizeOptionalText2(typeof candidate.title === "string" ? candidate.title : null);
+  const url = normalizeOptionalText(typeof candidate.url === "string" ? candidate.url : null);
+  const title = normalizeOptionalText(typeof candidate.title === "string" ? candidate.title : null);
   if (!url && !title) {
     return null;
   }
   return { type: "iframe", url, title };
 }
-function normalizeOptionalText2(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-var sortByUpdatedAtDesc2 = (left, right) => right.updatedAt - left.updatedAt;
-var readStorageValue2 = async (storageArea, key) => {
-  return await new Promise((resolve, reject) => {
-    storageArea.get(key, (items) => {
-      const error = chrome.runtime.lastError;
-      if (error) {
-        reject(new Error(error.message));
-        return;
-      }
-      resolve(items[key]);
-    });
-  });
-};
-var writeStorageValue2 = async (storageArea, items) => {
-  await new Promise((resolve, reject) => {
-    storageArea.set(items, () => {
-      const error = chrome.runtime.lastError;
-      if (error) {
-        reject(new Error(error.message));
-        return;
-      }
-      resolve();
-    });
-  });
-};
 
 // src/background/action-badge.ts
 var badgeSyncChain = Promise.resolve();
@@ -1516,10 +1538,8 @@ function createWatcherStatus(debuggerManager2, tabId, session, watcherInfo, curr
   const readiness = buildWatcherReadiness(debuggerManager2, tabId, session, watcherInfo, currentTarget);
   return {
     tabId,
-    bridgeConnected: readiness.nativeHostConnected,
-    nativeHostConnected: readiness.nativeHostConnected,
+    bridgeConnected: readiness.bridgeConnected,
     watcherReady: readiness.watcherReady,
-    targetReady: readiness.targetReady,
     targetState: readiness.targetState,
     watcherId: watcherInfo?.watcherId ?? null,
     watcherHost: watcherInfo?.watcherHost ?? null,
@@ -1530,13 +1550,14 @@ function createWatcherStatus(debuggerManager2, tabId, session, watcherInfo, curr
   };
 }
 function buildWatcherReadiness(debuggerManager2, tabId, session, watcherInfo, currentTarget) {
-  const nativeHostConnected = session.isConnected();
-  const watcherReady = nativeHostConnected && Boolean(watcherInfo?.watcherId && watcherInfo.watcherHost && watcherInfo.watcherPort != null);
+  const bridgeConnected = session.isConnected();
+  const watcherReady = bridgeConnected && Boolean(watcherInfo?.watcherId && watcherInfo.watcherHost && watcherInfo.watcherPort != null);
   const targetReady = currentTarget?.targetReady ?? getTargetReadiness(debuggerManager2, tabId, currentTarget);
   return {
-    nativeHostConnected,
+    bridgeConnected,
     watcherReady,
-    targetReady,
+    // targetReady is not surfaced on its own: the popup only ever renders this
+    // three-state derivation of it.
     targetState: targetReady == null ? "not-selected" : targetReady ? "ready" : "rebinding"
   };
 }
@@ -1565,9 +1586,14 @@ var controlBridgeSession = new ControlBridgeSession(debuggerManager, {
     recordEvent("error", "bridge", "Control native host disconnected");
   }
 });
-var bridgeSessions = /* @__PURE__ */ new Map();
-var selectedFrameByTabId = /* @__PURE__ */ new Map();
-var pendingRememberedTargetByTabId = /* @__PURE__ */ new Map();
+var attachments = /* @__PURE__ */ new Map();
+var bridgeSessions = {
+  get: (tabId) => attachments.get(tabId)?.session,
+  has: (tabId) => attachments.has(tabId),
+  keys: () => attachments.keys(),
+  values: () => [...attachments.values()].map((attachment) => attachment.session),
+  entries: () => [...attachments.entries()].map(([tabId, attachment]) => [tabId, attachment.session])
+};
 var targetSelectionHistory = new TargetSelectionHistoryStore();
 var targetVisibilityHistory = new TargetVisibilityHistoryStore();
 var recentEvents = [];
@@ -1634,7 +1660,7 @@ async function attachTabFromControl(tabId, options = {}) {
     }
     return { ok: true, tab, watcherId: session.getWatcherInfo()?.watcherId };
   } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    return { ok: false, error: formatError(error) };
   }
 }
 async function detachTabFromControl(tabId) {
@@ -1648,16 +1674,19 @@ async function detachTabFromControl(tabId) {
     }
     return { ok: true, tab };
   } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    return { ok: false, error: formatError(error) };
   }
 }
 async function buildPopupResponse(message) {
+  return await dispatchPopupAction(message);
+}
+async function dispatchPopupAction(message) {
   try {
     switch (message.action) {
       case "getTargets":
         return { success: true, tabs: await getTabsWithTargets() };
       case "attach": {
-        const tabId = requireTabId(message);
+        const { tabId } = message;
         await attachBridgeSession(tabId);
         setSelectedFrame(tabId, null);
         await prepareRememberedTargetSelection(tabId);
@@ -1665,24 +1694,23 @@ async function buildPopupResponse(message) {
         return { success: true };
       }
       case "detach": {
-        const tabId = requireTabId(message);
+        const { tabId } = message;
         await detachTab(tabId);
         recordEvent("info", "popup", `Detached tab ${tabId}`);
         return { success: true };
       }
       case "focusTab": {
-        const tabId = requireTabId(message);
+        const { tabId } = message;
         await focusTab(tabId);
         recordEvent("info", "popup", `Focused tab ${tabId}`);
         return { success: true };
       }
       case "selectTarget": {
-        const tabId = requireTabId(message);
+        const { tabId, frameId } = message;
         const session = bridgeSessions.get(tabId);
         if (!session) {
           return { success: false, error: `No watcher bridge for tab ${tabId}` };
         }
-        const frameId = message.frameId ?? null;
         const target = getPopupTarget(debuggerManager, tabId, frameId);
         if (!target) {
           return { success: false, error: `Unknown target for tab ${tabId}` };
@@ -1695,15 +1723,15 @@ async function buildPopupResponse(message) {
         return { success: true };
       }
       case "hideTarget": {
-        const tabId = requireTabId(message);
-        const target = getRequiredIframeTarget(debuggerManager, tabId, message.frameId ?? null);
+        const { tabId, frameId } = message;
+        const target = getRequiredIframeTarget(debuggerManager, tabId, frameId);
         await hideTarget(tabId, target);
         recordEvent("info", "popup", `Hid iframe ${target.frameId} on tab ${tabId}`);
         return { success: true };
       }
       case "showTarget": {
-        const tabId = requireTabId(message);
-        const target = getRequiredIframeTarget(debuggerManager, tabId, message.frameId ?? null);
+        const { tabId, frameId } = message;
+        const target = getRequiredIframeTarget(debuggerManager, tabId, frameId);
         await showTarget(tabId, target);
         recordEvent("info", "popup", `Restored iframe ${target.frameId} on tab ${tabId}`);
         return { success: true };
@@ -1713,8 +1741,6 @@ async function buildPopupResponse(message) {
           success: true,
           status: buildPopupStatusPayload()
         };
-      default:
-        return { success: false, error: `Unknown action: ${message.action}` };
     }
   } catch (err) {
     recordEvent("error", "popup", err instanceof Error ? err.message : "Unknown popup error");
@@ -1724,12 +1750,6 @@ async function buildPopupResponse(message) {
     };
   }
 }
-function requireTabId(message) {
-  if (message.tabId !== void 0) {
-    return message.tabId;
-  }
-  throw new Error("No tabId provided");
-}
 async function attachBridgeSession(tabId, options = {}) {
   const existing = bridgeSessions.get(tabId);
   if (existing) {
@@ -1756,7 +1776,7 @@ async function attachBridgeSession(tabId, options = {}) {
     },
     options
   );
-  bridgeSessions.set(tabId, session);
+  attachments.set(tabId, { session });
   await connectBridgeSession(tabId, session);
   return session;
 }
@@ -1783,16 +1803,11 @@ async function connectBridgeSession(tabId, session) {
   }
 }
 function clearTabState(tabId) {
-  selectedFrameByTabId.delete(tabId);
-  clearPendingRememberedTarget(tabId);
   destroyBridgeSession(tabId);
 }
 function pruneStaleBridgeSessions() {
-  for (const [tabId, session] of bridgeSessions.entries()) {
-    if (debuggerManager.isAttached(tabId)) {
-      continue;
-    }
-    if (!session.getTargetInfo()) {
+  for (const [tabId, attachment] of attachments.entries()) {
+    if (debuggerManager.isAttached(tabId) || !attachment.session.getTargetInfo()) {
       continue;
     }
     clearTabState(tabId);
@@ -1800,12 +1815,12 @@ function pruneStaleBridgeSessions() {
   }
 }
 function destroyBridgeSession(tabId) {
-  const session = bridgeSessions.get(tabId);
-  if (!session) {
+  const attachment = attachments.get(tabId);
+  if (!attachment) {
     return;
   }
-  bridgeSessions.delete(tabId);
-  session.dispose();
+  attachments.delete(tabId);
+  attachment.session.dispose();
 }
 function buildPopupStatusPayload() {
   return {
@@ -1815,8 +1830,7 @@ function buildPopupStatusPayload() {
       url: target.url,
       title: target.title
     })),
-    watchers: getWatcherStatuses(),
-    recentEvents
+    watchers: getWatcherStatuses()
   };
 }
 function buildControlDiagnostics() {
@@ -1904,10 +1918,7 @@ function syncSelectedFrameFromWatcher(targetId) {
   setSelectedFrame(target.tabId, target.frameId);
 }
 function getSelectedFrameId(tabId) {
-  if (!selectedFrameByTabId.has(tabId)) {
-    return void 0;
-  }
-  return selectedFrameByTabId.get(tabId) ?? null;
+  return attachments.get(tabId)?.selectedFrameId;
 }
 async function rememberTargetSelection(tabId, target) {
   const pageUrl = getPageUrlForTab(debuggerManager, tabId);
@@ -1962,9 +1973,9 @@ async function prepareRememberedTargetSelection(tabId) {
   await replayRememberedTargetSelection(tabId);
 }
 async function replayRememberedTargetSelection(tabId) {
-  const remembered = pendingRememberedTargetByTabId.get(tabId);
-  const session = bridgeSessions.get(tabId);
-  if (!remembered || !session) {
+  const attachment = attachments.get(tabId);
+  const remembered = attachment?.pendingRememberedTarget;
+  if (!attachment || !remembered) {
     return;
   }
   const target = matchRememberedIframeTarget(
@@ -1975,7 +1986,7 @@ async function replayRememberedTargetSelection(tabId) {
     return;
   }
   try {
-    session.selectTarget(target.frameId);
+    attachment.session.selectTarget(target.frameId);
     setSelectedFrame(tabId, target.frameId);
     clearPendingRememberedTarget(tabId);
     recordEvent("info", "bridge", `Restored iframe ${target.frameId} on tab ${tabId}`);
@@ -1984,16 +1995,25 @@ async function replayRememberedTargetSelection(tabId) {
   }
 }
 function shouldReplayRememberedTarget(tabId, method) {
-  return pendingRememberedTargetByTabId.has(tabId) && REMEMBERED_TARGET_RETRY_EVENTS.has(method);
+  return attachments.get(tabId)?.pendingRememberedTarget != null && REMEMBERED_TARGET_RETRY_EVENTS.has(method);
 }
 function setSelectedFrame(tabId, frameId) {
-  selectedFrameByTabId.set(tabId, frameId);
+  const attachment = attachments.get(tabId);
+  if (attachment) {
+    attachment.selectedFrameId = frameId;
+  }
 }
 function setPendingRememberedTarget(tabId, remembered) {
-  pendingRememberedTargetByTabId.set(tabId, remembered);
+  const attachment = attachments.get(tabId);
+  if (attachment) {
+    attachment.pendingRememberedTarget = remembered;
+  }
 }
 function clearPendingRememberedTarget(tabId) {
-  pendingRememberedTargetByTabId.delete(tabId);
+  const attachment = attachments.get(tabId);
+  if (attachment) {
+    delete attachment.pendingRememberedTarget;
+  }
 }
 console.log("[ServiceWorker] Argus CDP Bridge extension loaded");
 void syncActionBadge(debuggerManager);