Could not establish connection. Receiving end does not exist.

async function sendToTab<T>(tabId: number, message: unknown): Promise<T> {
  try {
    return await chrome.tabs.sendMessage(tabId, message);
  } catch (error) {
    if (!String(error).includes('Receiving end does not exist')) throw error;
    // No listener in this tab yet: inject the content script, then retry once.
    await chrome.scripting.executeScript({ target: { tabId }, files: ['content.js'] });
    return chrome.tabs.sendMessage(tabId, message);
  }
}

async function notifyOpenViews(message: unknown): Promise<void> {
  const views = await chrome.runtime.getContexts({ contextTypes: ['POPUP', 'SIDE_PANEL'] });
  if (views.length === 0) return;
  // The popup can close after the check; a missed update is fine.
  await chrome.runtime.sendMessage(message).catch(() => {});
}

let ready: Promise<void> | null = null;

function initialize(): Promise<void> {
  ready ??= loadSettingsAndRules().catch((error) => {
    ready = null; // let the next event retry
    throw error;
  });
  return ready;
}

// Registered synchronously, so it exists when a message wakes the worker.
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  void (async () => {
    try {
      await initialize();
      sendResponse(await handleMessage(message, sender));
    } catch (error) {
      sendResponse({ success: false, error: String(error) });
    }
  })();
  return true; // keep the channel open for the async reply
});

type ExtensionRuntime = {
  lastError?: { message?: string };
  sendMessage: (id: string, message: unknown, callback: (response: unknown) => void) => void;
};

function askExtension(extensionId: string, message: unknown, timeoutMs = 2500): Promise<unknown> {
  return new Promise((resolve, reject) => {
    const runtime = (window as Window & { chrome?: { runtime?: ExtensionRuntime } }).chrome?.runtime;
    // Undefined unless an installed extension lists this origin in externally_connectable.
    if (!runtime?.sendMessage) return reject(new Error('unavailable'));
    const timer = setTimeout(() => reject(new Error('timeout')), timeoutMs);
    runtime.sendMessage(extensionId, message, (response) => {
      clearTimeout(timer);
      // Wrong ID, extension not installed, or no onMessageExternal listener.
      if (runtime.lastError) reject(new Error('unavailable'));
      else resolve(response);
    });
  });
}

const TRUSTED_ORIGINS = new Set(['https://www.example.com']);

chrome.runtime.onMessageExternal.addListener((message, sender, sendResponse) => {
  if (!sender.origin || !TRUSTED_ORIGINS.has(sender.origin)) {
    sendResponse({ success: false, error: 'Unauthorized sender' });
    return false;
  }
  void handleExternal(message).then(sendResponse);
  return true;
});