@fairfox/polly 0.1.0

package/dist/shared/lib/state.js

@@ -0,0 +1,1265 @@
+// src/shared/adapters/chrome/context-menus.chrome.ts
+class ChromeContextMenusAdapter {
+  async create(createProperties) {
+    return new Promise((resolve, reject) => {
+      chrome.contextMenus.create(createProperties, () => {
+        if (chrome.runtime.lastError) {
+          reject(new Error(chrome.runtime.lastError.message));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  async update(id, updateProperties) {
+    await chrome.contextMenus.update(id, updateProperties);
+  }
+  async remove(id) {
+    await chrome.contextMenus.remove(id);
+  }
+  async removeAll() {
+    await chrome.contextMenus.removeAll();
+  }
+  onClicked(callback) {
+    chrome.contextMenus.onClicked.addListener(callback);
+  }
+}
+
+// src/shared/adapters/chrome/offscreen.chrome.ts
+class ChromeOffscreenAdapter {
+  async createDocument(parameters) {
+    await chrome.offscreen.createDocument({
+      url: parameters.url,
+      reasons: parameters.reasons,
+      justification: parameters.justification
+    });
+  }
+  async closeDocument() {
+    await chrome.offscreen.closeDocument();
+  }
+  async hasDocument() {
+    const existingContexts = await chrome.runtime.getContexts({
+      contextTypes: ["OFFSCREEN_DOCUMENT"]
+    });
+    return existingContexts.length > 0;
+  }
+}
+
+// src/shared/adapters/chrome/runtime.chrome.ts
+class ChromeRuntimeAdapter {
+  messageListeners = new Map;
+  static listenerCount = 0;
+  sendMessage(message) {
+    return chrome.runtime.sendMessage(message);
+  }
+  onMessage(callback) {
+    const wrappedCallback = (message, sender, sendResponse) => {
+      const mappedSender = {
+        ...sender.tab && {
+          tab: {
+            id: sender.tab.id ?? 0,
+            url: sender.tab.url ?? "",
+            title: sender.tab.title ?? ""
+          }
+        },
+        ...sender.frameId !== undefined && { frameId: sender.frameId },
+        ...sender.url && { url: sender.url }
+      };
+      return callback(message, mappedSender, sendResponse);
+    };
+    this.messageListeners.set(callback, wrappedCallback);
+    chrome.runtime.onMessage.addListener(wrappedCallback);
+    ChromeRuntimeAdapter.listenerCount++;
+    if (ChromeRuntimeAdapter.listenerCount > 1) {
+      console.warn(`⚠️  WARNING: ${ChromeRuntimeAdapter.listenerCount} chrome.runtime.onMessage listeners registered!
+
+Multiple listeners will cause message handlers to execute multiple times.
+This is usually caused by:
+  1. Creating both MessageBus and MessageRouter with separate listeners
+  2. Calling createBackground() multiple times
+  3. Calling getMessageBus('background') after createBackground()
+
+Fix: In background scripts, use createBackground() ONCE at startup.
+Do not call getMessageBus('background') separately.`);
+    }
+  }
+  removeMessageListener(callback) {
+    const wrappedCallback = this.messageListeners.get(callback);
+    if (wrappedCallback) {
+      chrome.runtime.onMessage.removeListener(wrappedCallback);
+      this.messageListeners.delete(callback);
+      ChromeRuntimeAdapter.listenerCount = Math.max(0, ChromeRuntimeAdapter.listenerCount - 1);
+    }
+  }
+  connect(name) {
+    const port = chrome.runtime.connect({ name });
+    return new ChromePortAdapter(port);
+  }
+  onConnect(callback) {
+    chrome.runtime.onConnect.addListener((port) => {
+      callback(new ChromePortAdapter(port));
+    });
+  }
+  getURL(path) {
+    return chrome.runtime.getURL(path);
+  }
+  getId() {
+    return chrome.runtime.id;
+  }
+  openOptionsPage() {
+    chrome.runtime.openOptionsPage();
+  }
+}
+
+class ChromePortAdapter {
+  port;
+  listeners = {
+    message: new Set,
+    disconnect: new Set
+  };
+  constructor(port) {
+    this.port = port;
+    this.port.onMessage.addListener((message) => {
+      for (const callback of this.listeners.message) {
+        callback(message);
+      }
+    });
+    this.port.onDisconnect.addListener(() => {
+      for (const callback of this.listeners.disconnect) {
+        callback();
+      }
+    });
+  }
+  get name() {
+    return this.port.name;
+  }
+  postMessage(message) {
+    this.port.postMessage(message);
+  }
+  onMessage(callback) {
+    this.listeners.message.add(callback);
+  }
+  onDisconnect(callback) {
+    this.listeners.disconnect.add(callback);
+  }
+  disconnect() {
+    this.port.disconnect();
+  }
+}
+
+// src/shared/adapters/chrome/storage.chrome.ts
+class ChromeStorageAdapter {
+  async get(keys) {
+    return await chrome.storage.local.get(keys);
+  }
+  async set(items) {
+    await chrome.storage.local.set(items);
+  }
+  async remove(keys) {
+    await chrome.storage.local.remove(keys);
+  }
+  async clear() {
+    await chrome.storage.local.clear();
+  }
+  onChanged(callback) {
+    chrome.storage.onChanged.addListener((changes, areaName) => {
+      const mappedChanges = {};
+      for (const [key, change] of Object.entries(changes)) {
+        mappedChanges[key] = {
+          oldValue: change.oldValue,
+          newValue: change.newValue
+        };
+      }
+      callback(mappedChanges, areaName);
+    });
+  }
+}
+
+// src/shared/adapters/chrome/tabs.chrome.ts
+class ChromeTabsAdapter {
+  async query(queryInfo) {
+    return chrome.tabs.query(queryInfo);
+  }
+  async get(tabId) {
+    return chrome.tabs.get(tabId);
+  }
+  async sendMessage(tabId, message) {
+    return chrome.tabs.sendMessage(tabId, message);
+  }
+  async reload(tabId, reloadProperties) {
+    await chrome.tabs.reload(tabId, reloadProperties);
+  }
+  onRemoved(callback) {
+    chrome.tabs.onRemoved.addListener(callback);
+  }
+  onUpdated(callback) {
+    chrome.tabs.onUpdated.addListener(callback);
+  }
+  onActivated(callback) {
+    chrome.tabs.onActivated.addListener(callback);
+  }
+  async create(createProperties) {
+    return chrome.tabs.create(createProperties);
+  }
+}
+
+// src/shared/adapters/chrome/window.chrome.ts
+class ChromeWindowAdapter {
+  postMessage(message, targetOrigin) {
+    window.postMessage(message, targetOrigin);
+  }
+  addEventListener(type, listener) {
+    window.addEventListener(type, listener);
+  }
+  removeEventListener(type, listener) {
+    window.removeEventListener(type, listener);
+  }
+}
+
+// src/shared/adapters/fetch.adapter.ts
+class BrowserFetchAdapter {
+  fetch(input, init) {
+    return fetch(input, init);
+  }
+}
+
+// src/shared/adapters/logger.adapter.ts
+class MessageLoggerAdapter {
+  runtime;
+  sourceContext;
+  options;
+  constructor(runtime, sourceContext, options) {
+    this.runtime = runtime;
+    this.sourceContext = sourceContext;
+    this.options = options;
+  }
+  debug(message, context) {
+    this.sendLog("debug", message, context);
+  }
+  info(message, context) {
+    this.sendLog("info", message, context);
+  }
+  warn(message, context) {
+    this.sendLog("warn", message, context);
+  }
+  error(message, error, context) {
+    this.sendLog("error", message, context, error);
+  }
+  log(level, message, context) {
+    this.sendLog(level, message, context);
+  }
+  sendLog(level, message, context, error) {
+    if (this.options?.consoleMirror) {
+      const consoleMethod = console[level] || console.log;
+      consoleMethod(`[${this.sourceContext}]`, message, context || "", error || "");
+    }
+    const logMessage = {
+      type: "LOG",
+      level,
+      message,
+      context,
+      error: error?.message,
+      stack: error?.stack,
+      source: this.sourceContext,
+      timestamp: Date.now()
+    };
+    this.runtime.sendMessage(logMessage).catch((sendError) => {
+      if (this.options?.fallbackToConsole !== false) {
+        console[level](`[${this.sourceContext}] ${message}`, context || "", error || "");
+        console.warn("Failed to send log message:", sendError);
+      }
+    });
+  }
+}
+
+// src/shared/adapters/index.ts
+function createChromeAdapters(context, options) {
+  const runtime2 = new ChromeRuntimeAdapter;
+  return {
+    runtime: runtime2,
+    storage: new ChromeStorageAdapter,
+    tabs: new ChromeTabsAdapter,
+    window: new ChromeWindowAdapter,
+    offscreen: new ChromeOffscreenAdapter,
+    contextMenus: new ChromeContextMenusAdapter,
+    fetch: new BrowserFetchAdapter,
+    logger: new MessageLoggerAdapter(runtime2, context, {
+      ...options?.consoleMirror !== undefined && { consoleMirror: options.consoleMirror },
+      fallbackToConsole: true
+    })
+  };
+}
+
+// src/shared/types/messages.ts
+var ALL_CONTEXTS = [
+  "background",
+  "content",
+  "page",
+  "devtools",
+  "popup",
+  "options",
+  "sidepanel",
+  "offscreen"
+];
+var defaultSettings = {
+  theme: "auto",
+  autoSync: true,
+  debugMode: false,
+  notifications: true,
+  apiEndpoint: "https://api.example.com",
+  refreshInterval: 60000
+};
+
+// src/shared/lib/errors.ts
+class ExtensionError extends Error {
+  code;
+  context;
+  constructor(message, code, context) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.name = this.constructor.name;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+}
+
+class TimeoutError extends ExtensionError {
+  timeoutMs;
+  constructor(message, timeoutMs, context) {
+    super(message, "TIMEOUT_ERROR", { ...context, timeoutMs });
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+class ConnectionError extends ExtensionError {
+  constructor(message, context) {
+    super(message, "CONNECTION_ERROR", context);
+  }
+}
+
+class MessageRouterError extends ExtensionError {
+  constructor(message, context) {
+    super(message, "MESSAGE_ROUTER_ERROR", context);
+  }
+}
+
+class HandlerError extends ExtensionError {
+  messageType;
+  constructor(message, messageType, context) {
+    super(message, "HANDLER_ERROR", { ...context, messageType });
+    this.messageType = messageType;
+  }
+}
+
+class APIError extends ExtensionError {
+  statusCode;
+  constructor(message, statusCode, context) {
+    super(message, "API_ERROR", { ...context, statusCode });
+    this.statusCode = statusCode;
+  }
+}
+
+class OffscreenError extends ExtensionError {
+  constructor(message, context) {
+    super(message, "OFFSCREEN_ERROR", context);
+  }
+}
+
+class ErrorHandler {
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  throw(error) {
+    this.logger.error(error.message, error, error.context);
+    throw error;
+  }
+  reject(error) {
+    this.logger.error(error.message, error, error.context);
+    return error;
+  }
+  wrap(error, message, code, context) {
+    const originalError = error instanceof Error ? error : new Error(String(error));
+    const wrappedError = new ExtensionError(`${message}: ${originalError.message}`, code, {
+      ...context,
+      originalError: originalError.message,
+      originalStack: originalError.stack
+    });
+    if (originalError.stack) {
+      wrappedError.stack = originalError.stack;
+    }
+    this.logger.error(wrappedError.message, wrappedError, wrappedError.context);
+    return wrappedError;
+  }
+}
+
+// src/shared/lib/context-specific-helpers.ts
+function createContentScriptHelpers() {
+  return {
+    getPageInfo() {
+      return {
+        url: window.location.href,
+        title: document.title,
+        host: window.location.host,
+        pathname: window.location.pathname,
+        readyState: document.readyState
+      };
+    },
+    queryElements(selector) {
+      const elements = document.querySelectorAll(selector);
+      return Array.from(elements).map((el) => ({
+        tagName: el.tagName,
+        id: el.id,
+        className: el.className,
+        textContent: el.textContent?.slice(0, 100) || ""
+      }));
+    },
+    getPageMetadata() {
+      const metadata = {};
+      const metaTags = document.querySelectorAll("meta");
+      for (const tag of Array.from(metaTags)) {
+        const name = tag.getAttribute("name") || tag.getAttribute("property");
+        const content = tag.getAttribute("content");
+        if (name && content) {
+          metadata[name] = content;
+        }
+      }
+      return metadata;
+    },
+    injectCSS(css) {
+      const styleId = `ext-injected-${Date.now()}`;
+      const style = document.createElement("style");
+      style.id = styleId;
+      style.textContent = css;
+      document.head.appendChild(style);
+    },
+    removeCSS(styleId) {
+      const style = document.getElementById(styleId);
+      if (style) {
+        style.remove();
+      }
+    }
+  };
+}
+function createDevToolsHelpers() {
+  return {
+    get inspectedTabId() {
+      return chrome.devtools?.inspectedWindow?.tabId;
+    },
+    evalInPage(code) {
+      return new Promise((resolve, reject) => {
+        if (!chrome.devtools?.inspectedWindow) {
+          reject(new Error("DevTools inspectedWindow not available"));
+          return;
+        }
+        chrome.devtools.inspectedWindow.eval(code, (result, error) => {
+          if (error) {
+            reject(new Error(error.isException ? error.value : "Execution error"));
+          } else {
+            resolve(result);
+          }
+        });
+      });
+    },
+    getPageResource(url) {
+      return new Promise((resolve, reject) => {
+        if (!chrome.devtools?.inspectedWindow) {
+          reject(new Error("DevTools inspectedWindow not available"));
+          return;
+        }
+        chrome.devtools.inspectedWindow.getResources((resources) => {
+          const resource = resources.find((r) => r.url === url);
+          if (!resource) {
+            reject(new Error(`Resource not found: ${url}`));
+            return;
+          }
+          resource.getContent((content, encoding) => {
+            if (encoding === "base64") {
+              resolve(atob(content));
+            } else {
+              resolve(content);
+            }
+          });
+        });
+      });
+    },
+    reloadInspectedPage(options = {}) {
+      if (!chrome.devtools?.inspectedWindow) {
+        console.warn("DevTools inspectedWindow not available");
+        return;
+      }
+      chrome.devtools.inspectedWindow.reload(options);
+    }
+  };
+}
+function createPopupHelpers(adapters) {
+  return {
+    async getCurrentTab() {
+      const tabs2 = await adapters.tabs.query({ active: true, currentWindow: true });
+      return tabs2[0];
+    },
+    closePopup() {
+      window.close();
+    },
+    setDimensions(width, height) {
+      document.body.style.width = `${width}px`;
+      document.body.style.height = `${height}px`;
+    }
+  };
+}
+function createOptionsHelpers(adapters) {
+  return {
+    openInNewTab(path) {
+      adapters.tabs.create({ url: path });
+    },
+    showSaveConfirmation(message = "Settings saved!", duration = 3000) {
+      const notification = document.createElement("div");
+      notification.textContent = message;
+      notification.style.cssText = `
+        position: fixed;
+        top: 20px;
+        right: 20px;
+        background: #4caf50;
+        color: white;
+        padding: 12px 24px;
+        border-radius: 4px;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+        z-index: 10000;
+        animation: slideIn 0.3s ease;
+      `;
+      document.body.appendChild(notification);
+      setTimeout(() => {
+        notification.style.animation = "slideOut 0.3s ease";
+        setTimeout(() => notification.remove(), 300);
+      }, duration);
+    },
+    showError(message, duration = 5000) {
+      const notification = document.createElement("div");
+      notification.textContent = message;
+      notification.style.cssText = `
+        position: fixed;
+        top: 20px;
+        right: 20px;
+        background: #f44336;
+        color: white;
+        padding: 12px 24px;
+        border-radius: 4px;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+        z-index: 10000;
+        animation: slideIn 0.3s ease;
+      `;
+      document.body.appendChild(notification);
+      setTimeout(() => {
+        notification.style.animation = "slideOut 0.3s ease";
+        setTimeout(() => notification.remove(), 300);
+      }, duration);
+    }
+  };
+}
+function createSidePanelHelpers(adapters) {
+  return {
+    async getCurrentTab() {
+      const tabs2 = await adapters.tabs.query({ active: true, currentWindow: true });
+      return tabs2[0];
+    },
+    isVisible() {
+      return document.visibilityState === "visible";
+    },
+    setWidth(width) {
+      document.body.style.width = `${width}px`;
+    }
+  };
+}
+function createBackgroundHelpers(adapters) {
+  return {
+    async getAllTabs() {
+      return adapters.tabs.query({});
+    },
+    getExtensionViews(type) {
+      return chrome.extension.getViews(type ? { type } : undefined);
+    },
+    openOptionsPage() {
+      adapters.runtime.openOptionsPage();
+    },
+    setBadge(text, color = "#f44336") {
+      chrome.action.setBadgeText({ text });
+      chrome.action.setBadgeBackgroundColor({ color });
+    },
+    clearBadge() {
+      chrome.action.setBadgeText({ text: "" });
+    }
+  };
+}
+
+// src/shared/lib/handler-execution-tracker.ts
+class HandlerExecutionTracker {
+  executions = new Map;
+  isDevelopment;
+  constructor() {
+    this.isDevelopment = typeof process !== "undefined" && (process.env?.NODE_ENV === "development" || process.env?.NODE_ENV === "test");
+  }
+  track(messageId, handlerType) {
+    if (!this.isDevelopment)
+      return;
+    let handlerCounts = this.executions.get(messageId);
+    if (!handlerCounts) {
+      handlerCounts = new Map;
+      this.executions.set(messageId, handlerCounts);
+    }
+    const count = (handlerCounts.get(handlerType) || 0) + 1;
+    handlerCounts.set(handlerType, count);
+    if (count > 1) {
+      const error = new Error(`\uD83D\uDD34 DOUBLE EXECUTION DETECTED
+
+Handler "${handlerType}" executed ${count} times for message ${messageId}.
+
+This indicates multiple chrome.runtime.onMessage listeners are registered.
+Common causes:
+  1. Both MessageBus and MessageRouter registered listeners
+  2. createBackground() called multiple times
+  3. Handler registered in multiple places
+
+Fix: Ensure only ONE listener is registered. In background scripts,
+use createBackground() instead of getMessageBus().
+`);
+      console.error(error);
+      console.error("Execution trace for message:", messageId);
+      console.error(Array.from(handlerCounts.entries()));
+      throw error;
+    }
+    setTimeout(() => {
+      this.executions.delete(messageId);
+    }, 5000);
+  }
+  reset() {
+    this.executions.clear();
+  }
+  getExecutionCount(messageId, handlerType) {
+    return this.executions.get(messageId)?.get(handlerType) || 0;
+  }
+}
+var globalExecutionTracker = new HandlerExecutionTracker;
+
+// src/shared/lib/message-bus.ts
+function isRoutedMessage(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("id" in value) || !("source" in value) || !("targets" in value) || !("payload" in value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.source === "string" && Array.isArray(value.targets) && typeof value.payload === "object" && value.payload !== null;
+}
+function isRoutedResponse(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("id" in value) || !("success" in value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.success === "boolean";
+}
+
+class MessageBus {
+  context;
+  adapters;
+  helpers;
+  pendingRequests = new Map;
+  handlers = new Map;
+  port = null;
+  errorHandler;
+  userErrorHandlers = [];
+  messageListener = null;
+  constructor(context, adapters, options) {
+    this.context = context;
+    this.adapters = adapters || createChromeAdapters(context);
+    this.errorHandler = new ErrorHandler(this.adapters.logger);
+    this.helpers = this.createContextHelpers();
+    if (!options?.skipListenerSetup) {
+      this.setupListeners();
+    }
+  }
+  async send(payload, options) {
+    const id = crypto.randomUUID();
+    let targets;
+    if (options?.target) {
+      if (Array.isArray(options.target)) {
+        targets = options.target;
+      } else {
+        targets = [options.target];
+      }
+    } else {
+      const inferredTarget = this.inferTarget(payload.type);
+      if (!inferredTarget) {
+        throw new Error(`Message type "${payload.type}" is not a framework message. Please provide explicit 'target' option.`);
+      }
+      targets = Array.isArray(inferredTarget) ? inferredTarget : [inferredTarget];
+    }
+    const message = {
+      id,
+      source: this.context,
+      targets,
+      ...options?.tabId !== undefined && { tabId: options.tabId },
+      timestamp: Date.now(),
+      payload
+    };
+    return new Promise((resolve, reject) => {
+      const timeoutMs = options?.timeout || 5000;
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        const error = new TimeoutError(`Message timeout: ${payload.type}`, timeoutMs, {
+          messageType: payload.type,
+          targets
+        });
+        this.notifyErrorHandlers(error);
+        reject(this.errorHandler.reject(error));
+      }, timeoutMs);
+      this.pendingRequests.set(id, {
+        resolve: (value) => {
+          clearTimeout(timeout);
+          resolve(value);
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        },
+        timestamp: Date.now(),
+        timeout
+      });
+      this.sendMessage(message);
+    });
+  }
+  broadcast(payload) {
+    const message = {
+      id: crypto.randomUUID(),
+      source: this.context,
+      targets: ALL_CONTEXTS,
+      timestamp: Date.now(),
+      payload
+    };
+    this.sendMessage(message);
+  }
+  on(type, handler) {
+    const existing = this.handlers.get(type) || [];
+    existing.push(handler);
+    this.handlers.set(type, existing);
+  }
+  registerHandlers(handlers) {
+    for (const [type, handler] of Object.entries(handlers)) {
+      if (handler) {
+        const existing = this.handlers.get(type) || [];
+        existing.push(handler);
+        this.handlers.set(type, existing);
+      }
+    }
+  }
+  onError(handler) {
+    this.userErrorHandlers.push(handler);
+  }
+  async sendToBackground(payload, options) {
+    return this.send(payload, { ...options, target: "background" });
+  }
+  async sendToContentScript(tabId, payload, options) {
+    return this.send(payload, { ...options, target: "content", tabId });
+  }
+  async sendToAllTabs(payload, options) {
+    const tabs2 = await this.adapters.tabs.query({});
+    return Promise.all(tabs2.map((tab) => tab.id ? this.sendToContentScript(tab.id, payload, options) : Promise.resolve(undefined)));
+  }
+  async sendToPopup(payload, options) {
+    return this.send(payload, { ...options, target: "popup" });
+  }
+  async sendToOptions(payload, options) {
+    return this.send(payload, { ...options, target: "options" });
+  }
+  async sendToDevTools(payload, options) {
+    return this.send(payload, { ...options, target: "devtools" });
+  }
+  async sendToSidePanel(payload, options) {
+    return this.send(payload, { ...options, target: "sidepanel" });
+  }
+  connect(name) {
+    if (this.port) {
+      console.warn(`[${this.context}] Port already connected: ${this.port.name}`);
+      return;
+    }
+    this.port = this.adapters.runtime.connect(name);
+    this.port.onMessage((message) => {
+      if (isRoutedMessage(message) || isRoutedResponse(message)) {
+        this.handleMessage(message);
+      }
+    });
+    this.port.onDisconnect(() => {
+      this.adapters.logger.warn("Port disconnected", {
+        context: this.context,
+        portName: name
+      });
+      this.port = null;
+      for (const [id, pending] of this.pendingRequests.entries()) {
+        const error = new ConnectionError("Port disconnected", {
+          context: this.context,
+          portName: name,
+          requestId: id
+        });
+        this.notifyErrorHandlers(error);
+        pending.reject(this.errorHandler.reject(error));
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(id);
+      }
+    });
+  }
+  disconnect() {
+    if (this.port) {
+      this.port.disconnect();
+      this.port = null;
+    }
+  }
+  destroy() {
+    this.disconnect();
+    this.handlers.clear();
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timeout);
+    }
+    this.pendingRequests.clear();
+    if (this.messageListener) {
+      this.adapters.runtime.removeMessageListener(this.messageListener);
+    }
+  }
+  setupListeners() {
+    this.messageListener = (message, sender, sendResponse) => {
+      if (isRoutedMessage(message) || isRoutedResponse(message)) {
+        this.handleMessage(message, sender).then((response) => sendResponse(response)).catch((error) => {
+          sendResponse({ success: false, error: error.message });
+        });
+      }
+      return true;
+    };
+    this.adapters.runtime.onMessage(this.messageListener);
+    if (this.context === "content" || this.context === "page") {
+      this.adapters.window.addEventListener("message", (event) => {
+        if (event.source !== window)
+          return;
+        if (event.data?.__extensionMessage) {
+          this.handleMessage(event.data.message);
+        }
+      });
+    }
+  }
+  async handleMessage(message, _sender) {
+    if ("success" in message) {
+      const pending = this.pendingRequests.get(message.id);
+      if (pending) {
+        this.pendingRequests.delete(message.id);
+        clearTimeout(pending.timeout);
+        if (message.success) {
+          pending.resolve(message.data ?? undefined);
+        } else {
+          const error = new HandlerError(message.error || "Unknown error", "unknown", {
+            messageId: message.id
+          });
+          this.notifyErrorHandlers(error);
+          pending.reject(this.errorHandler.reject(error));
+        }
+      }
+      return;
+    }
+    if (!message.targets.includes(this.context)) {
+      if (this.context === "background") {
+        return;
+      }
+      return;
+    }
+    const handlers = this.handlers.get(message.payload.type);
+    if (!handlers || handlers.length === 0) {
+      if (message.targets.length === 1) {
+        console.warn(`[${this.context}] No handler for message type: ${message.payload.type}`);
+      }
+      return { success: false, error: "No handler" };
+    }
+    if (message.targets.length > 1) {
+      try {
+        globalExecutionTracker.track(message.id, message.payload.type);
+        await Promise.all(handlers.map((handler) => handler(message.payload, message)));
+        return { success: true, data: undefined, timestamp: Date.now() };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error",
+          timestamp: Date.now()
+        };
+      }
+    }
+    if (message.payload.type === "LOG") {
+      try {
+        globalExecutionTracker.track(message.id, message.payload.type);
+        await Promise.all(handlers.map((handler) => handler(message.payload, message)));
+        const response = {
+          id: message.id,
+          success: true,
+          timestamp: Date.now()
+        };
+        this.sendResponse(message, response);
+        return response;
+      } catch (error) {
+        const response = {
+          id: message.id,
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error",
+          timestamp: Date.now()
+        };
+        this.sendResponse(message, response);
+        return response;
+      }
+    }
+    try {
+      globalExecutionTracker.track(message.id, message.payload.type);
+      const handler = handlers[0];
+      if (!handler) {
+        throw new Error(`Handler not found for ${message.payload.type}`);
+      }
+      const data = await handler(message.payload, message);
+      const response = {
+        id: message.id,
+        success: true,
+        data,
+        timestamp: Date.now()
+      };
+      this.sendResponse(message, response);
+      return response;
+    } catch (error) {
+      const response = {
+        id: message.id,
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        timestamp: Date.now()
+      };
+      this.sendResponse(message, response);
+      return response;
+    }
+  }
+  sendMessage(message) {
+    if (this.context === "content" && message.targets.includes("page")) {
+      this.adapters.window.postMessage({ __extensionMessage: true, message }, "*");
+    } else if (this.context === "page") {
+      this.adapters.window.postMessage({ __extensionMessage: true, message }, "*");
+    } else if (this.port) {
+      this.port.postMessage(message);
+    } else {
+      this.adapters.runtime.sendMessage(message);
+    }
+  }
+  sendResponse(request, response) {
+    if (this.context === "content" && request.source === "page") {
+      this.adapters.window.postMessage({ __extensionMessage: true, message: response }, "*");
+    } else if (this.context === "page" && request.source === "content") {
+      this.adapters.window.postMessage({ __extensionMessage: true, message: response }, "*");
+    } else if (this.port && (this.context === "devtools" || this.context === "content")) {
+      this.port.postMessage(response);
+    } else {
+      this.adapters.runtime.sendMessage(response);
+    }
+  }
+  inferTarget(type) {
+    const handlers = {
+      DOM_QUERY: "content",
+      DOM_UPDATE: "content",
+      DOM_INSERT: "content",
+      DOM_REMOVE: "content",
+      PAGE_EVAL: "page",
+      PAGE_GET_VAR: "page",
+      PAGE_CALL_FN: "page",
+      PAGE_SET_VAR: "page",
+      API_REQUEST: "background",
+      API_BATCH: "background",
+      CLIPBOARD_WRITE: "offscreen",
+      CLIPBOARD_WRITE_HTML: "offscreen",
+      CLIPBOARD_WRITE_RICH: "offscreen",
+      CLIPBOARD_READ: "offscreen",
+      CONTEXT_MENU_CREATE: "background",
+      CONTEXT_MENU_REMOVE: "background",
+      STATE_SYNC: ALL_CONTEXTS,
+      TAB_QUERY: "background",
+      TAB_GET_CURRENT: "background",
+      TAB_RELOAD: "background",
+      LOG: "background",
+      LOGS_GET: "background",
+      LOGS_CLEAR: "background",
+      LOGS_EXPORT: "background"
+    };
+    function isHandlerKey(key) {
+      return key in handlers;
+    }
+    if (isHandlerKey(type)) {
+      return handlers[type];
+    }
+    return;
+  }
+  createContextHelpers() {
+    switch (this.context) {
+      case "content":
+        return createContentScriptHelpers();
+      case "devtools":
+        return createDevToolsHelpers();
+      case "popup":
+        return createPopupHelpers(this.adapters);
+      case "options":
+        return createOptionsHelpers(this.adapters);
+      case "sidepanel":
+        return createSidePanelHelpers(this.adapters);
+      case "background":
+        return createBackgroundHelpers(this.adapters);
+      default:
+        return {};
+    }
+  }
+  notifyErrorHandlers(error) {
+    for (const handler of this.userErrorHandlers) {
+      try {
+        handler(error, this);
+      } catch (handlerError) {
+        console.error(`[${this.context}] Error in error handler:`, handlerError);
+      }
+    }
+  }
+}
+function getMessageBus(context, adapters, options) {
+  return new MessageBus(context, adapters, options);
+}
+
+// src/shared/lib/state.ts
+import { effect, signal } from "@preact/signals";
+var stateRegistry = new Map;
+function getCurrentContext() {
+  if (typeof chrome !== "undefined") {
+    if (typeof chrome.devtools !== "undefined") {
+      return "devtools";
+    }
+    if (typeof chrome.runtime !== "undefined") {
+      try {
+        if (typeof self !== "undefined" && "ServiceWorkerGlobalScope" in self) {
+          return "background";
+        }
+      } catch {}
+    }
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    if (typeof chrome === "undefined" || typeof chrome.runtime === "undefined") {
+      return "page";
+    }
+    if (typeof window.location !== "undefined" && window.location.protocol === "chrome-extension:") {
+      const path = window.location.pathname;
+      if (path.includes("/popup"))
+        return "popup";
+      if (path.includes("/options"))
+        return "options";
+      if (path.includes("/offscreen"))
+        return "offscreen";
+    }
+    return "content";
+  }
+  return "background";
+}
+function $sharedState(key, initialValue, options = {}) {
+  return createState(key, initialValue, {
+    ...options,
+    sync: true,
+    persist: true
+  });
+}
+function $syncedState(key, initialValue, options = {}) {
+  return createState(key, initialValue, {
+    ...options,
+    sync: true,
+    persist: false
+  });
+}
+function $persistedState(key, initialValue, options = {}) {
+  return createState(key, initialValue, {
+    ...options,
+    sync: false,
+    persist: true
+  });
+}
+function $state(initialValue) {
+  return signal(initialValue);
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return false;
+  if (typeof a !== "object" || typeof b !== "object")
+    return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key))
+      return false;
+    if (!deepEqual(a[key], b[key]))
+      return false;
+  }
+  return true;
+}
+function createState(key, initialValue, options) {
+  if (stateRegistry.has(key)) {
+    return stateRegistry.get(key)?.signal;
+  }
+  const currentContext = getCurrentContext();
+  if (currentContext === "page" && (options.sync || options.persist)) {
+    const stateFn = options.sync && options.persist ? "$sharedState" : options.persist ? "$persistedState" : "$syncedState";
+    throw new Error(`[web-ext] ${stateFn}() is not available in page context.
+Page scripts are execution contexts for content scripts and should not maintain state.
+Use state in the content script instead, or use $state() for local-only state.`);
+  }
+  const sig = signal(initialValue);
+  const entry = {
+    signal: sig,
+    clock: 0,
+    loaded: Promise.resolve(),
+    updating: false
+  };
+  let bus = null;
+  const getBus = () => {
+    if (!bus && typeof chrome !== "undefined") {
+      bus = options.bus || getMessageBus(currentContext);
+    }
+    return bus;
+  };
+  if (options.persist) {
+    entry.loaded = loadFromStorage(key, sig, entry, getBus(), options.validator);
+  }
+  entry.loaded.then(() => {
+    let debounceTimer = null;
+    let previousValue = sig.value;
+    let isFirstRun = true;
+    effect(() => {
+      if (entry.updating)
+        return;
+      const value = sig.value;
+      if (isFirstRun) {
+        isFirstRun = false;
+        return;
+      }
+      if (deepEqual(value, previousValue)) {
+        return;
+      }
+      previousValue = value;
+      entry.clock++;
+      const doUpdate = () => {
+        if (options.persist) {
+          persistToStorage(key, value, entry.clock, getBus());
+        }
+        if (options.sync) {
+          broadcastUpdate(key, value, entry.clock, getBus());
+        }
+      };
+      if (options.debounceMs) {
+        if (debounceTimer)
+          clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(doUpdate, options.debounceMs);
+      } else {
+        doUpdate();
+      }
+    });
+  });
+  if (options.sync) {
+    const messageBus = getBus();
+    if (messageBus) {
+      if (currentContext === "popup" || currentContext === "options" || currentContext === "devtools") {
+        messageBus.connect(currentContext);
+      }
+      messageBus.on("STATE_SYNC", async (payload) => {
+        if (payload.key !== key)
+          return;
+        const oldClock = entry.clock;
+        entry.clock = Math.max(entry.clock, payload.clock);
+        if (payload.clock > oldClock) {
+          if (options.validator && !options.validator(payload.value)) {
+            console.warn(`[web-ext] State "${key}": Received invalid value from sync (clock: ${payload.clock})`, payload.value);
+            return;
+          }
+          if (deepEqual(entry.signal.value, payload.value)) {
+            return;
+          }
+          applyUpdate(entry, payload.value, payload.clock);
+        }
+        return;
+      });
+    }
+  }
+  stateRegistry.set(key, entry);
+  return sig;
+}
+async function loadFromStorage(key, sig, entry, bus, validator) {
+  if (!bus)
+    return;
+  try {
+    const result = await bus.adapters.storage.get([key, `${key}:clock`]);
+    if (result[key] !== undefined) {
+      const storedValue = result[key];
+      if (validator) {
+        if (validator(storedValue)) {
+          sig.value = storedValue;
+        } else {
+          console.warn(`[web-ext] State "${key}": Stored value failed validation, using initial value`, storedValue);
+        }
+      } else {
+        sig.value = storedValue;
+      }
+    }
+    if (result[`${key}:clock`] !== undefined) {
+      entry.clock = result[`${key}:clock`];
+    }
+  } catch (error) {
+    console.warn(`[web-ext] Failed to load state from storage: ${key}`, error);
+  }
+}
+function persistToStorage(key, value, clock, bus) {
+  if (!bus)
+    return;
+  try {
+    bus.adapters.storage.set({
+      [key]: value,
+      [`${key}:clock`]: clock
+    });
+  } catch (error) {
+    console.warn(`Failed to persist state to storage: ${key}`, error);
+  }
+}
+function broadcastUpdate(key, value, clock, bus) {
+  if (!bus)
+    return;
+  try {
+    bus.broadcast({
+      type: "STATE_SYNC",
+      key,
+      value,
+      clock
+    });
+  } catch (error) {
+    console.warn(`Failed to broadcast state update: ${key}`, error);
+  }
+}
+function applyUpdate(entry, value, clock) {
+  entry.updating = true;
+  entry.signal.value = value;
+  entry.clock = clock;
+  entry.updating = false;
+}
+function getStateByKey(key) {
+  const entry = stateRegistry.get(key);
+  return entry?.signal;
+}
+function clearStateRegistry() {
+  stateRegistry.clear();
+}
+export {
+  getStateByKey,
+  clearStateRegistry,
+  $syncedState,
+  $state,
+  $sharedState,
+  $persistedState
+};
+
+//# debugId=054D660650837F1D64756E2164756E21