@fairfox/polly 0.14.0 → 0.15.0

package/dist/src/shared/lib/state.js

@@ -48,1194 +48,301 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/shared/lib/constraints.ts
-var exports_constraints = {};
-__export(exports_constraints, {
-  registerConstraints: () => registerConstraints,
-  registerConstraint: () => registerConstraint,
-  isRuntimeConstraintsEnabled: () => isRuntimeConstraintsEnabled,
-  getRegisteredConstraints: () => getRegisteredConstraints,
-  clearConstraints: () => clearConstraints,
-  checkPreconditions: () => checkPreconditions,
-  checkPostconditions: () => checkPostconditions
-});
-function registerConstraint(field, messageType, constraint) {
-  if (!registry.has(field)) {
-    registry.set(field, new Map);
-  }
-  registry.get(field)?.set(messageType, constraint);
-}
-function registerConstraints(field, constraints) {
-  for (const [messageType, constraint] of Object.entries(constraints)) {
-    const runtimeConstraint = {
-      message: constraint.message
-    };
-    if (typeof constraint.requires === "function") {
-      runtimeConstraint.requires = constraint.requires;
-    }
-    if (typeof constraint.ensures === "function") {
-      runtimeConstraint.ensures = constraint.ensures;
-    }
-    if (runtimeConstraint.requires || runtimeConstraint.ensures) {
-      registerConstraint(field, messageType, runtimeConstraint);
-    }
-  }
-}
-function executeConstraint(predicate, state, messageType, field, customMessage, constraintType = "Precondition") {
-  try {
-    const result = predicate(state);
-    if (!result) {
-      const message = customMessage || `${constraintType} failed for ${messageType} on field ${field}`;
-      throw new Error(message);
-    }
-  } catch (error) {
-    if (error instanceof Error && error.message.includes(`${constraintType} failed`)) {
-      throw error;
-    }
-    const message = customMessage || `${constraintType} check error for ${messageType} on field ${field}`;
-    throw new Error(`${message}: ${error}`);
-  }
-}
-function checkPreconditions(messageType, state) {
-  for (const [field, constraints] of registry) {
-    const constraint = constraints.get(messageType);
-    if (constraint?.requires) {
-      executeConstraint(constraint.requires, state, messageType, field, constraint.message, "Precondition");
-    }
-  }
-}
-function checkPostconditions(messageType, state) {
-  for (const [field, constraints] of registry) {
-    const constraint = constraints.get(messageType);
-    if (constraint?.ensures) {
-      executeConstraint(constraint.ensures, state, messageType, field, constraint.message, "Postcondition");
-    }
-  }
-}
-function clearConstraints() {
-  registry.clear();
-}
-function getRegisteredConstraints() {
-  return new Map(registry);
-}
-function isRuntimeConstraintsEnabled() {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env["POLLY_RUNTIME_CONSTRAINTS"] === "true";
-  }
-  if (typeof Bun !== "undefined" && Bun.env) {
-    return Bun.env["POLLY_RUNTIME_CONSTRAINTS"] === "true";
-  }
-  return false;
-}
-var registry;
-var init_constraints = __esm(() => {
-  registry = new Map;
+// src/shared/lib/storage-adapter.ts
+var exports_storage_adapter = {};
+__export(exports_storage_adapter, {
+  createStorageAdapter: () => createStorageAdapter,
+  MemoryStorageAdapter: () => MemoryStorageAdapter,
+  IndexedDBAdapter: () => IndexedDBAdapter,
+  ChromeStorageAdapter: () => ChromeStorageAdapter
 });
 
-// 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();
+class IndexedDBAdapter {
+  dbName;
+  storeName = "state";
+  dbPromise = null;
+  constructor(dbName = "polly-state") {
+    this.dbName = dbName;
+  }
+  getDB() {
+    if (this.dbPromise)
+      return this.dbPromise;
+    this.dbPromise = new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName);
         }
-      });
-    });
-  }
-  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;
+    return this.dbPromise;
   }
-}
-
-// 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 ?? ""
+  async get(keys) {
+    try {
+      const db = await this.getDB();
+      const result = {};
+      await Promise.all(keys.map((key) => new Promise((resolve, reject) => {
+        const transaction = db.transaction([this.storeName], "readonly");
+        const store = transaction.objectStore(this.storeName);
+        const request = store.get(key);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => {
+          if (request.result !== undefined) {
+            result[key] = request.result;
           }
-        },
-        ...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.`);
+          resolve();
+        };
+      })));
+      return result;
+    } catch (error) {
+      console.warn("[Polly] IndexedDB get failed:", error);
+      return {};
     }
   }
-  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);
+  async set(items) {
+    try {
+      const db = await this.getDB();
+      await Promise.all(Object.entries(items).map(([key, value]) => new Promise((resolve, reject) => {
+        const transaction = db.transaction([this.storeName], "readwrite");
+        const store = transaction.objectStore(this.storeName);
+        const request = store.put(value, key);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve();
+      })));
+    } catch (error) {
+      console.warn("[Polly] IndexedDB set failed:", error);
     }
   }
-  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();
+  async remove(keys) {
+    try {
+      const db = await this.getDB();
+      await Promise.all(keys.map((key) => new Promise((resolve, reject) => {
+        const transaction = db.transaction([this.storeName], "readwrite");
+        const store = transaction.objectStore(this.storeName);
+        const request = store.delete(key);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve();
+      })));
+    } catch (error) {
+      console.warn("[Polly] IndexedDB remove failed:", error);
+    }
   }
 }
 
-// src/shared/adapters/chrome/storage.chrome.ts
 class ChromeStorageAdapter {
   async get(keys) {
-    if (keys === null) {
-      return await chrome.storage.local.get();
+    if (typeof chrome === "undefined" || !chrome.storage) {
+      return {};
+    }
+    try {
+      return await chrome.storage.local.get(keys);
+    } catch (error) {
+      console.warn("[Polly] Chrome storage get failed:", error);
+      return {};
     }
-    return await chrome.storage.local.get(keys);
   }
   async set(items) {
-    await chrome.storage.local.set(items);
+    if (typeof chrome === "undefined" || !chrome.storage) {
+      return;
+    }
+    try {
+      await chrome.storage.local.set(items);
+    } catch (error) {
+      console.warn("[Polly] Chrome storage set failed:", error);
+    }
   }
   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) {
-    if (reloadProperties) {
-      await chrome.tabs.reload(tabId, reloadProperties);
-    } else {
-      await chrome.tabs.reload(tabId);
+    if (typeof chrome === "undefined" || !chrome.storage) {
+      return;
     }
-  }
-  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 || "");
+    try {
+      await chrome.storage.local.remove(keys);
+    } catch (error) {
+      console.warn("[Polly] Chrome storage remove failed:", 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 MemoryStorageAdapter {
+  storage = new Map;
+  async get(keys) {
+    const result = {};
+    for (const key of keys) {
+      const value = this.storage.get(key);
+      if (value !== undefined) {
+        result[key] = value;
+      }
+    }
+    return result;
   }
-}
-
-class ConnectionError extends ExtensionError {
-  constructor(message, context) {
-    super(message, "CONNECTION_ERROR", context);
+  async set(items) {
+    for (const [key, value] of Object.entries(items)) {
+      this.storage.set(key, value);
+    }
   }
-}
-
-class MessageRouterError extends ExtensionError {
-  constructor(message, context) {
-    super(message, "MESSAGE_ROUTER_ERROR", context);
+  async remove(keys) {
+    for (const key of keys) {
+      this.storage.delete(key);
+    }
   }
 }
-
-class HandlerError extends ExtensionError {
-  messageType;
-  constructor(message, messageType, context) {
-    super(message, "HANDLER_ERROR", { ...context, messageType });
-    this.messageType = messageType;
+function createStorageAdapter() {
+  if (typeof chrome !== "undefined" && chrome.storage && chrome.runtime) {
+    return new ChromeStorageAdapter;
   }
-}
-
-class APIError extends ExtensionError {
-  statusCode;
-  constructor(message, statusCode, context) {
-    super(message, "API_ERROR", { ...context, statusCode });
-    this.statusCode = statusCode;
+  if (typeof indexedDB !== "undefined") {
+    return new IndexedDBAdapter;
   }
+  return new MemoryStorageAdapter;
 }
 
-class OffscreenError extends ExtensionError {
-  constructor(message, context) {
-    super(message, "OFFSCREEN_ERROR", context);
-  }
-}
+// src/shared/lib/sync-adapter.ts
+var exports_sync_adapter = {};
+__export(exports_sync_adapter, {
+  createSyncAdapter: () => createSyncAdapter,
+  NoOpSyncAdapter: () => NoOpSyncAdapter,
+  ChromeRuntimeSyncAdapter: () => ChromeRuntimeSyncAdapter,
+  BroadcastChannelSyncAdapter: () => BroadcastChannelSyncAdapter
+});
 
-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;
+class NoOpSyncAdapter {
+  broadcast(_message) {}
+  onMessage(_callback) {
+    return () => {};
   }
 }
 
-// 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);
-            }
+class ChromeRuntimeSyncAdapter {
+  listeners = [];
+  port = null;
+  constructor() {
+    if (typeof chrome !== "undefined" && chrome.runtime) {
+      chrome.runtime.onMessage.addListener((message, _sender, _sendResponse) => {
+        if (message.type === "STATE_SYNC") {
+          this.listeners.forEach((listener) => {
+            listener(message);
           });
-        });
+        }
       });
-    },
-    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 === "popup" || type === "tab") ? { 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)
+  broadcast(message) {
+    if (typeof chrome === "undefined" || !chrome.runtime) {
+      console.warn("[SyncAdapter] chrome.runtime not available");
       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 = [];
-  stateAccessor = null;
-  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();
+    try {
+      chrome.runtime.sendMessage({
+        type: "STATE_SYNC",
+        key: message.key,
+        value: message.value,
+        clock: message.clock
+      });
+    } catch (error) {
+      console.warn("[SyncAdapter] Failed to broadcast state update:", error);
     }
   }
-  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.`);
+  onMessage(callback) {
+    this.listeners.push(callback);
+    return () => {
+      const index = this.listeners.indexOf(callback);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
       }
-      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);
-  }
-  setStateAccessor(accessor) {
-    this.stateAccessor = accessor;
-  }
-  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);
-      }
-    });
+  connect() {
+    return Promise.resolve();
   }
   disconnect() {
+    this.listeners = [];
     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);
-        }
-      });
-    }
+  isConnected() {
+    return typeof chrome !== "undefined" && !!chrome.runtime;
   }
-  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
+}
+
+class BroadcastChannelSyncAdapter {
+  channel = null;
+  listeners = [];
+  constructor(channelName = "polly-sync") {
+    if (typeof BroadcastChannel !== "undefined") {
+      this.channel = new BroadcastChannel(channelName);
+      this.channel.onmessage = (event) => {
+        if (event.data.type === "STATE_SYNC") {
+          this.listeners.forEach((listener) => {
+            listener(event.data);
           });
-          this.notifyErrorHandlers(error);
-          pending.reject(this.errorHandler.reject(error));
         }
-      }
-      return;
+      };
+    } else {
+      console.warn("[SyncAdapter] BroadcastChannel not available");
     }
-    if (!message.targets.includes(this.context)) {
-      if (this.context === "background") {
-        return;
-      }
+  }
+  broadcast(message) {
+    if (!this.channel) {
+      console.warn("[SyncAdapter] BroadcastChannel not initialized");
       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);
-      if (this.stateAccessor) {
-        try {
-          const { checkPreconditions: checkPreconditions2, isRuntimeConstraintsEnabled: isRuntimeConstraintsEnabled2 } = await Promise.resolve().then(() => (init_constraints(), exports_constraints));
-          if (isRuntimeConstraintsEnabled2()) {
-            const currentState = this.stateAccessor();
-            checkPreconditions2(message.payload.type, currentState);
-          }
-        } catch (error) {
-          if (error instanceof Error) {
-            throw error;
-          }
-          if (error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND") {} else {
-            throw error;
-          }
-        }
-      }
-      const handler = handlers[0];
-      if (!handler) {
-        throw new Error(`Handler not found for ${message.payload.type}`);
-      }
-      const data = await handler(message.payload, message);
-      if (this.stateAccessor) {
-        try {
-          const { checkPostconditions: checkPostconditions2, isRuntimeConstraintsEnabled: isRuntimeConstraintsEnabled2 } = await Promise.resolve().then(() => (init_constraints(), exports_constraints));
-          if (isRuntimeConstraintsEnabled2()) {
-            const currentState = this.stateAccessor();
-            checkPostconditions2(message.payload.type, currentState);
-          }
-        } catch (error) {
-          if (error instanceof Error && error.message.includes("Postcondition")) {
-            console.error(`[${this.context}] Postcondition failed:`, error.message);
-          }
-        }
-      }
-      const response = {
-        id: message.id,
-        success: true,
-        data,
-        timestamp: Date.now()
-      };
-      this.sendResponse(message, response);
-      return response;
+      this.channel.postMessage({
+        type: "STATE_SYNC",
+        key: message.key,
+        value: message.value,
+        clock: message.clock
+      });
     } 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;
+      console.warn("[SyncAdapter] Failed to broadcast state update:", error);
     }
   }
-  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"
+  onMessage(callback) {
+    this.listeners.push(callback);
+    return () => {
+      const index = this.listeners.indexOf(callback);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
     };
-    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 {};
-    }
+  connect() {
+    return Promise.resolve();
   }
-  notifyErrorHandlers(error) {
-    for (const handler of this.userErrorHandlers) {
-      try {
-        handler(error, this);
-      } catch (handlerError) {
-        console.error(`[${this.context}] Error in error handler:`, handlerError);
-      }
+  disconnect() {
+    this.listeners = [];
+    if (this.channel) {
+      this.channel.close();
+      this.channel = null;
     }
   }
+  isConnected() {
+    return this.channel !== null;
+  }
 }
-function getMessageBus(context, adapters, options) {
-  return new MessageBus(context, adapters, options);
+function createSyncAdapter() {
+  if (typeof chrome !== "undefined" && chrome.runtime) {
+    return new ChromeRuntimeSyncAdapter;
+  }
+  if (typeof BroadcastChannel !== "undefined") {
+    return new BroadcastChannelSyncAdapter;
+  }
+  return new NoOpSyncAdapter;
 }
 
 // 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 = {}) {
   const sig = createState(key, initialValue, {
     ...options,
-    sync: true,
-    persist: true
+    enableSync: true,
+    enablePersist: true
   });
   const entry = stateRegistry.get(key);
   if (entry) {
@@ -1246,15 +353,15 @@ function $sharedState(key, initialValue, options = {}) {
 function $syncedState(key, initialValue, options = {}) {
   return createState(key, initialValue, {
     ...options,
-    sync: true,
-    persist: false
+    enableSync: true,
+    enablePersist: false
   });
 }
 function $persistedState(key, initialValue, options = {}) {
   const sig = createState(key, initialValue, {
     ...options,
-    sync: false,
-    persist: true
+    enableSync: false,
+    enablePersist: true
   });
   const entry = stateRegistry.get(key);
   if (entry) {
@@ -1284,17 +391,28 @@ function deepEqual(a, b) {
   }
   return true;
 }
+function resolveAdapters(options) {
+  if (options.storage || options.sync) {
+    return {
+      storage: options.storage || (options.enablePersist ? createStorageAdapter() : null),
+      sync: options.sync || (options.enableSync ? createSyncAdapter() : null)
+    };
+  }
+  if (options.bus) {
+    return {
+      storage: options.bus.adapters.storage,
+      sync: options.enableSync ? createSyncAdapter() : null
+    };
+  }
+  return {
+    storage: options.enablePersist ? createStorageAdapter() : null,
+    sync: options.enableSync ? createSyncAdapter() : null
+  };
+}
 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);
   if (options.verify) {
     const mirror = JSON.parse(JSON.stringify(initialValue));
@@ -1306,15 +424,9 @@ Use state in the content script instead, or use $state() for local-only state.`)
     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);
+  const adapters = resolveAdapters(options);
+  if (options.enablePersist && adapters.storage) {
+    entry.loaded = loadFromStorage(key, sig, entry, adapters.storage, options.validator);
   }
   entry.loaded.then(() => {
     let debounceTimer = null;
@@ -1340,11 +452,11 @@ Use state in the content script instead, or use $state() for local-only state.`)
       }
       entry.clock++;
       const doUpdate = () => {
-        if (options.persist) {
-          persistToStorage(key, value, entry.clock, getBus());
+        if (options.enablePersist && adapters.storage) {
+          persistToStorage(key, value, entry.clock, adapters.storage);
         }
-        if (options.sync) {
-          broadcastUpdate(key, value, entry.clock, getBus());
+        if (options.enableSync && adapters.sync) {
+          broadcastUpdate(key, value, entry.clock, adapters.sync);
         }
       };
       if (options.debounceMs) {
@@ -1356,46 +468,40 @@ Use state in the content script instead, or use $state() for local-only state.`)
       }
     });
   });
-  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)
+  if (options.enableSync && adapters.sync) {
+    if (adapters.sync.connect) {
+      adapters.sync.connect();
+    }
+    adapters.sync.onMessage((message) => {
+      if (message.key !== key)
+        return;
+      const oldClock = entry.clock;
+      entry.clock = Math.max(entry.clock, message.clock);
+      if (message.clock > oldClock) {
+        if (options.validator && !options.validator(message.value)) {
+          console.warn(`[Polly] State "${key}": Received invalid value from sync (clock: ${message.clock})`, message.value);
           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;
-      });
-    }
+        if (deepEqual(entry.signal.value, message.value)) {
+          return;
+        }
+        applyUpdate(entry, message.value, message.clock);
+      }
+    });
   }
   stateRegistry.set(key, entry);
   return sig;
 }
-async function loadFromStorage(key, sig, entry, bus, validator) {
-  if (!bus)
-    return;
+async function loadFromStorage(key, sig, entry, storage, validator) {
   try {
-    const result = await bus.adapters.storage.get([key, `${key}:clock`]);
+    const result = await 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);
+          console.warn(`[Polly] State "${key}": Stored value failed validation, using initial value`, storedValue);
         }
       } else {
         sig.value = storedValue;
@@ -1405,33 +511,28 @@ async function loadFromStorage(key, sig, entry, bus, validator) {
       entry.clock = result[`${key}:clock`];
     }
   } catch (error) {
-    console.warn(`[web-ext] Failed to load state from storage: ${key}`, error);
+    console.warn(`[Polly] Failed to load state from storage: ${key}`, error);
   }
 }
-function persistToStorage(key, value, clock, bus) {
-  if (!bus)
-    return;
+function persistToStorage(key, value, clock, storage) {
   try {
-    bus.adapters.storage.set({
+    storage.set({
       [key]: value,
       [`${key}:clock`]: clock
     });
   } catch (error) {
-    console.warn(`Failed to persist state to storage: ${key}`, error);
+    console.warn(`[Polly] Failed to persist state to storage: ${key}`, error);
   }
 }
-function broadcastUpdate(key, value, clock, bus) {
-  if (!bus)
-    return;
+function broadcastUpdate(key, value, clock, sync) {
   try {
-    bus.broadcast({
-      type: "STATE_SYNC",
+    sync.broadcast({
       key,
       value,
       clock
     });
   } catch (error) {
-    console.warn(`Failed to broadcast state update: ${key}`, error);
+    console.warn(`[Polly] Failed to broadcast state update: ${key}`, error);
   }
 }
 function applyUpdate(entry, value, clock) {
@@ -1456,4 +557,4 @@ export {
   $persistedState
 };
 
-//# debugId=30E85DBFA071F76364756E2164756E21
+//# debugId=44A9C265AE724F4564756E2164756E21