content.js

(function () {
  const FRAME_ID = "shiki-docs-skin-frame";
  const STYLE_ID = "shiki-docs-skin-style";
  const HOST_SOURCE = "shiki-host";
  const SKIN_SOURCE = "shiki-docs-skin";
  const STORAGE_KEY = "shikiDocsSkinEnabled";
  const PROFILE_KEY = "shikiProfileImage";
  const RICH_KEY = "shikiRichFormatting";
  const IMAGE_CONTROL_KEY = "shikiImageControl";
  const CAPABILITIES_KEY = "shikiDetectedCapabilities";
  const NATIVE_CONTROL_MASK_CLASS = "shiki-native-control-suppressed";
  const SYNC_INTERVAL_MS = 1500;
  const CAPABILITY_REFRESH_MS = 5 * 60 * 1000;
  const ROUTE_WATCH_MS = 1500;
  const SKIN_ORIGIN = new URL(chrome.runtime.getURL("index.html")).origin;
  const ADAPTERS = globalThis.ShikiProviderAdapters || null;
  const EXTENSION_VERSION = chrome.runtime.getManifest().version;
  const CAPABILITY_SCHEMA_VERSION = ADAPTERS?.CAPABILITY_SCHEMA_VERSION || 1;
  // Capability snapshots are per-browser-session performance hints, so they
  // live in chrome.storage.session when available (cleared when Chrome exits;
  // the background script grants content scripts access). storage.local is the
  // fallback for older Chrome builds only.
  const capabilityStorage = chrome.storage.session || chrome.storage.local;

  // Routes on supported hosts where Shiki must not inject or scan: sign-in,
  // consent, onboarding, legal, checkout, and share-view pages. The chat app
  // itself stays fully supported.
  const BLOCKED_ROUTE_PATTERN = /^\/(?:login|log-in|signin|sign-in|signup|sign-up|register|auth(?:orize)?|oauth|sso|magic-link|onboarding|welcome|consent|terms|tos|privacy|legal|policies|pricing|plans|upgrade|billing|checkout|payment|subscribe|careers|blog|press|about|help|support|docs|status)(?:\/|$)/i;

  function isSupportedRoute(pathname = location.pathname) {
    return !BLOCKED_ROUTE_PATTERN.test(String(pathname || "/"));
  }

  // Coarse route family used to key/invalidate capability caches: the first
  // path segment groups "/", "/c/…", "/chat/…", "/search/…" style app areas.
  function routeFamily(pathname = location.pathname) {
    const segment = String(pathname || "/").split("/").filter(Boolean)[0] || "root";
    return segment.toLowerCase();
  }

  // Development diagnostics for the capability cache (surfaced in the popup's
  // diagnostics section; in-memory only, never persisted).
  const cacheStats = { hits: 0, misses: 0, invalidations: 0, lastScanDurationMs: 0 };

  // The content script now runs at document_end (not document_idle) so the
  // workspace appears as soon as the DOM exists. Provider apps hydrate their
  // controls afterwards, so early scans that find no trigger retry with
  // backoff instead of caching a false "unavailable" for the whole TTL.
  const PAGE_START = Date.now();
  let earlyScanRetries = 0;
  let routeHydrationStartedAt = PAGE_START;

  const PROVIDERS = {
    "chatgpt.com": {
      name: "ChatGPT",
      defaultModel: { id: "gpt-5.6-sol", label: "GPT-5.6 Sol" },
      conversationPatterns: ["/c/"],
      conversationSelectors: ['a[href*="/c/"]']
    },
    "chat.openai.com": {
      name: "ChatGPT",
      defaultModel: { id: "gpt-5.6-sol", label: "GPT-5.6 Sol" },
      conversationPatterns: ["/c/"],
      conversationSelectors: ['a[href*="/c/"]']
    },
    "claude.ai": {
      name: "Claude",
      defaultModel: { id: "sonnet-5", label: "Sonnet 5" },
      conversationPatterns: ["/chat/"],
      conversationSelectors: ['a[href*="/chat/"]']
    },
    "gemini.google.com": {
      name: "Gemini",
      defaultModel: { id: "gemini-3.1-flash-lite", label: "Gemini 3.1 Flash-Lite" },
      conversationPatterns: ["/app/"],
      conversationSelectors: ['a[href*="/app/"]']
    },
    "grok.com": {
      name: "Grok",
      defaultModel: { id: "grok", label: "Grok" },
      conversationPatterns: ["/c/", "/chat/"],
      conversationSelectors: ['a[href*="/c/"]', 'a[href*="/chat/"]']
    },
    "chat.deepseek.com": {
      name: "DeepSeek",
      defaultModel: { id: "deepseek", label: "DeepSeek" },
      conversationPatterns: ["/a/chat/s/", "/chat/s/"],
      conversationSelectors: ['a[href*="/a/chat/s/"]', 'a[href*="/chat/s/"]']
    },
    "copilot.microsoft.com": {
      name: "Copilot",
      defaultModel: { id: "copilot", label: "Copilot" },
      conversationPatterns: ["/chats/", "/chat/"],
      conversationSelectors: ['a[href*="/chats/"]', 'a[href*="/chat/"]']
    },
    "www.perplexity.ai": {
      name: "Perplexity",
      defaultModel: { id: "best", label: "Best" },
      conversationPatterns: ["/search/", "/page/"],
      conversationSelectors: ['a[href*="/search/"]', 'a[href*="/page/"]']
    },
    "www.meta.ai": {
      name: "Meta AI",
      defaultModel: { id: "muse-spark", label: "Muse Spark" },
      conversationPatterns: ["/c/", "/chat/"],
      conversationSelectors: ['a[href*="/c/"]', 'a[href*="/chat/"]']
    },
    "meta.ai": {
      name: "Meta AI",
      defaultModel: { id: "muse-spark", label: "Muse Spark" },
      conversationPatterns: ["/c/", "/chat/"],
      conversationSelectors: ['a[href*="/c/"]', 'a[href*="/chat/"]']
    },
    "character.ai": {
      name: "Character.AI",
      defaultModel: { id: "character", label: "Character" },
      conversationPatterns: ["/chat/"],
      conversationSelectors: ['a[href*="/chat/"]']
    },
    "poe.com": {
      name: "Poe",
      defaultModel: { id: "assistant", label: "Assistant" },
      conversationPatterns: ["/chat/"],
      conversationSelectors: ['a[href*="/chat/"]']
    },
    "pi.ai": {
      name: "Pi",
      defaultModel: { id: "pi", label: "Pi" },
      conversationPatterns: ["/talk/", "/chat/"],
      conversationSelectors: ['a[href*="/talk/"]', 'a[href*="/chat/"]']
    },
    "hey.pi.ai": {
      name: "Pi",
      defaultModel: { id: "pi", label: "Pi" },
      conversationPatterns: ["/talk/", "/chat/"],
      conversationSelectors: ['a[href*="/talk/"]', 'a[href*="/chat/"]']
    },
    "chat.mistral.ai": {
      name: "Vibe",
      defaultModel: { id: "vibe", label: "Vibe" },
      conversationPatterns: ["/chat/"],
      conversationSelectors: ['a[href*="/chat/"]']
    },
    "chat.qwen.ai": {
      name: "Qwen",
      defaultModel: { id: "qwen3.7-plus", label: "Qwen3.7-Plus" },
      conversationPatterns: ["/c/", "/chat/"],
      conversationSelectors: ['a[href*="/c/"]', 'a[href*="/chat/"]']
    },
    "www.kimi.com": {
      name: "Kimi",
      defaultModel: { id: "kimi-k2.6", label: "K2.6" },
      conversationPatterns: ["/chat/", "/c/"],
      conversationSelectors: ['a[href*="/chat/"]', 'a[href*="/c/"]']
    }
  };

  let frame = null;
  let enabled = true;
  let voicePassthrough = false;
  let syncTimer = 0;
  let profileImage = "";
  // When on, assistant turns are reverse-engineered from the host's rendered
  // markdown into a structured AST (see extractBlocks) so the skin can show
  // headings/lists/code/etc. Toggled from the popup; persisted in storage.
  let richFormatting = true;
  let imageControl = "composer";
  let historyLoading = false;
  let historyHasMore = true;
  // Sidebar (conversation list) lazy loading, mirrored to the skin.
  let conversationsLoading = false;
  let conversationsHasMore = true;
  let detectedCapabilities = null;
  let capabilityScanPromise = null;
  let lastCapabilityScan = 0;
  let capabilityErrorRetries = 0;
  let lastFrameRemountAt = 0;
  let frameRemountWindowStart = 0;
  let frameRemountCount = 0;
  let frameKeeperObserver = null;
  let lastPostedState = null;
  let nativeControlMaskDepth = 0;

  // Cache of converted image sources (blob:/tainted -> data: URL). The cache is
  // bounded because data URLs are base64-expanded strings and can otherwise pin a
  // lot of tab memory in image-heavy chats.
  const IMAGE_CACHE_MAX_ENTRIES = 24;
  const IMAGE_CACHE_MAX_BYTES = 24 * 1024 * 1024;
  const IMAGE_CACHE_MAX_ITEM_BYTES = 4 * 1024 * 1024;
  const IMAGE_CONVERT_MAX_SOURCE_BYTES = 8 * 1024 * 1024;
  const IMAGE_CONVERT_MAX_EDGE = 1600;
  const IMAGE_CONVERT_MAX_PIXELS = 2560000;
  const IMAGE_CONVERT_MAX_IN_FLIGHT = 6;
  const IMAGE_CONVERT_TIMEOUT_MS = 10000;
  const IMAGE_CONVERT_JPEG_QUALITY = 0.86;
  const IMAGE_CACHE_MAX_DROPPED_SOURCES = 100;
  const imageDataCache = new Map();
  const imageDataCacheBytes = new Map();
  const droppedImageSources = new Set();
  const imageConverting = new Set();
  let imageDataCacheTotalBytes = 0;
  let imageCacheGeneration = 0;
  // `imageCacheVersion` bumps when a conversion lands so memoized message blocks
  // re-walk and pick it up.
  let imageCacheVersion = 0;

  function provider() {
    const local = PROVIDERS[location.hostname] || {
      name: "AI",
      defaultModel: { id: "gpt-5.5", label: "GPT-5.5" },
      conversationPatterns: [],
      conversationSelectors: ["a[href]"]
    };
    const shared = ADAPTERS?.PROVIDERS?.[local.name];
    return shared?.defaultModel ? { ...local, defaultModel: shared.defaultModel } : local;
  }

  function cleanText(value) {
    return String(value || "")
      .replace(/\s+/g, " ")
      .replace(/\b(new chat|delete|archive|share|more|options)\b/gi, "")
      .trim();
  }

  // Menu navigation words are meaningful capability evidence (notably Claude's
  // "More models"). Keep them intact while normalizing only whitespace.
  function surfaceOptionText(value) {
    return String(value || "").replace(/\s+/g, " ").trim();
  }

  function absoluteHref(href) {
    try {
      return new URL(href, location.origin).href;
    } catch {
      return "";
    }
  }

  // Stable conversation identity: canonical path with query/hash stripped, and
  // provider-specific slug normalization (Perplexity retitles its slugs, which
  // used to create one duplicate "Perplexity" row per title change).
  function normalizeId(href, index) {
    const url = absoluteHref(href);
    if (!url) return `conversation-${index + 1}`;
    if (ADAPTERS?.canonicalConversationId) {
      return ADAPTERS.canonicalConversationId(provider().name, url) || `conversation-${index + 1}`;
    }
    return new URL(url).pathname || `conversation-${index + 1}`;
  }

  function titleFromDocument() {
    const rawTitle = document.title
      .replace(/\s*[-|]\s*(ChatGPT|Claude|Gemini|Grok|DeepSeek|Copilot|Perplexity|Meta AI|Character\.AI|Poe|Pi|Vibe|Mistral|Qwen|Kimi).*$/i, "")
      .replace(/^ChatGPT\s*[-|]\s*/i, "");

    return cleanText(rawTitle) || "Conversation Name";
  }

  function isConversationHref(href, config) {
    const normalized = absoluteHref(href);
    if (!normalized) return false;
    return config.conversationPatterns.some((pattern) => normalized.includes(pattern));
  }

  function extractConversations() {
    const config = provider();
    const seen = new Set();
    const anchors = config.conversationSelectors.flatMap((selector) => Array.from(document.querySelectorAll(selector)));
    const conversations = [];

    anchors.forEach((anchor, index) => {
      const href = absoluteHref(anchor.getAttribute("href"));
      if (!href || !isConversationHref(href, config)) return;

      // De-duplicate by canonical conversation id, not raw href: the same
      // thread can be linked with different query strings, hashes, or retitled
      // slugs (Perplexity), which previously produced duplicate rows.
      const id = normalizeId(href, index);
      if (seen.has(id)) return;

      const title = cleanText(anchor.textContent) || titleFromDocument();
      if (!title || title.length < 2) return;

      seen.add(id);
      conversations.push({
        id,
        href,
        title,
        label: title
      });
    });

    if (!conversations.length) {
      conversations.push({
        id: normalizeId(location.href, 0) || "current",
        href: location.href,
        title: titleFromDocument(),
        label: "Tab 1"
      });
    }

    // Surface everything the host currently has in its DOM (it lazy-loads its own
    // sidebar, so this is however many it has rendered). The skin's list scrolls,
    // so we don't need to keep them all on screen at once.
    return conversations.slice(0, 200);
  }

  function extractActiveConversation(conversations) {
    const exact = conversations.find((conversation) => conversation.href === location.href);
    if (exact) return exact;

    // Match by canonical id so query strings and retitled slugs still resolve
    // to the already-listed row instead of a phantom duplicate.
    const currentId = normalizeId(location.href, 0);
    const idMatch = conversations.find((conversation) => conversation.id === currentId);
    if (idMatch) return idMatch;

    const currentPath = location.pathname;
    const pathMatch = conversations.find((conversation) => {
      try {
        return new URL(conversation.href).pathname === currentPath;
      } catch {
        return false;
      }
    });

    return pathMatch || conversations[0];
  }

  function modelSelectors() {
    const host = location.hostname;
    if (host.includes("chatgpt") || host.includes("openai")) {
      // ChatGPT folds the model picker into the composer's effort pill: opening it
      // shows the reasoning levels plus a current-model row that expands the model
      // list. The pill carries no testid/aria-label, but its class is stable. Older
      // top-bar switcher selectors are kept as fallbacks.
      return ['button.__composer-pill', '[data-testid="model-switcher-dropdown-button"]', '[data-testid*="model-switcher" i]'];
    }
    if (host.includes("claude")) {
      return ['[data-testid="model-selector-dropdown"]', 'button[aria-haspopup="listbox"]', 'button[aria-label*="model" i]'];
    }
    if (host.includes("gemini")) {
      // Gemini's "mode picker" button (Material) is the trigger; its visible pill
      // only shows an abbreviated name ("Flash-Lite"). The aria-label-based
      // selectors target the real button; the pill div is a last-resort fallback.
      return ['button[aria-label*="mode picker" i]', 'button[aria-label*="currently" i]', '.logo-pill-label-container'];
    }
    if (host.includes("grok")) {
      return [
        'button[aria-label*="model" i]:not([aria-label*="voice" i])',
        'button[aria-label*="mode" i]:not([aria-label*="voice" i])',
        'button[data-testid*="model" i]',
        'button[data-testid*="mode" i]:not([data-testid*="voice" i])'
      ];
    }
    if (host.includes("deepseek")) {
      return [
        'button[aria-label*="model" i]:not([aria-label*="deepthink" i]):not([aria-label*="thinking" i])',
        'button[aria-label*="mode" i]:not([aria-label*="deepthink" i]):not([aria-label*="thinking" i])',
        'button[data-testid*="model" i]',
        'button[data-testid*="mode" i]:not([data-testid*="deepthink" i]):not([data-testid*="thinking" i])',
        '[class*="model" i] button',
        '[class*="mode" i] button:not([aria-label*="deepthink" i]):not([aria-label*="thinking" i])'
      ];
    }
    if (host.includes("perplexity")) {
      return [
        'button[aria-label*="model" i]:not([aria-label*="voice" i])',
        'button[aria-label*="mode" i]:not([aria-label*="voice" i])',
        'button[data-testid*="model" i]',
        'button[data-testid*="mode" i]:not([data-testid*="voice" i])'
      ];
    }
    if (host.includes("poe")) {
      return ['button[aria-label*="bot" i]', 'button[aria-label*="model" i]', 'button[data-testid*="bot" i]', 'button[data-testid*="model" i]'];
    }
    if (host.includes("character")) {
      return ['button[aria-label*="chat style" i]', 'button[aria-label*="model" i]', 'button[data-testid*="chat-style" i]', 'button[data-testid*="model" i]', '[class*="chat-style" i] button'];
    }
    if (host.includes("kimi")) {
      // Kimi's model chip is a plain Vue div (no ARIA, no testid); the
      // semantic class name is the only stable hook (verified 2026-07-18,
      // shows e.g. "K2.6").
      return [
        '[role="button"][aria-label*="model" i]:not([aria-label*="voice" i])',
        'button[aria-label*="model" i]:not([aria-label*="voice" i])',
        'button[data-testid*="model" i]',
        '.current-model',
        '.chat-editor-action'
      ];
    }
    if (host.includes("mistral")) {
      // Vibe's current Fast/Think/Research trigger has no aria-label or model/
      // mode class. Its composer-row ancestor is the stable discriminator from
      // settings and voice menus elsewhere on the page.
      return [
        '[class*="chat-input-row"] button[aria-haspopup="menu"]:not([aria-label*="voice" i])',
        'button[aria-label*="mode" i]:not([aria-label*="voice" i]):not([aria-label*="live" i])',
        'button[data-testid*="mode" i]:not([data-testid*="voice" i])'
      ];
    }
    if (host.includes("copilot") || host.includes("meta.ai") || host.includes("qwen")) {
      // Voice/live controls also carry "mode" in their labels ("Voice Mode" on
      // Vibe); they must never be treated as the model/mode picker. Custom
      // comboboxes are often DIVs with button/combobox roles (Qwen's "Select
      // Model" is one), so role-based selectors come before tag-based ones.
      return [
        '[role="button"][aria-label*="model" i]:not([aria-label*="voice" i])',
        '[role="combobox"][aria-label*="model" i]',
        '[aria-haspopup="listbox"][aria-label*="model" i]:not([aria-label*="voice" i])',
        'button[aria-label*="model" i]:not([aria-label*="voice" i])',
        'button[aria-label*="mode" i]:not([aria-label*="voice" i]):not([aria-label*="live" i])',
        'button[data-testid*="model" i]',
        'button[data-testid*="mode" i]:not([data-testid*="voice" i])',
        '[class*="model" i] button:not([aria-label*="voice" i])',
        '[class*="mode" i] button:not([aria-label*="voice" i])'
      ];
    }
    // Pi is a single-assistant experience without a consumer model picker.
    return [];
  }

  // Providers with reasoning/mode choices generally expose them from the same
  // picker as the model. The provider-specific navigation in switchEffort opens the right
  // nested row before selecting a leaf, avoiding the old broad "thinking" click
  // that could flip a toggle instead of selecting an effort.
  function effortSelectors() {
    const host = location.hostname;
    if (host.includes("qwen")) {
      // "Select Mode" opens Qwen's tools menu. The reasoning effort is a
      // separate Ant combobox whose visible label contains the active value.
      return ['.qwen-select-thinking-label', 'input[role="combobox"][aria-label="Thinking"]'];
    }
    if (host.includes("perplexity")) {
      // Search workflows live in a second composer menu, separate from Model.
      return ['button[aria-haspopup="menu"][aria-pressed]'];
    }
    return modelSelectors();
  }

  function inlinePrimaryControl() {
    if (!location.hostname.includes("deepseek")) return null;
    return Array.from(document.querySelectorAll('[role="radio"][data-model-type], [role="radio"][aria-checked]'))
      .find((el) => isElementVisible(el)) || null;
  }

  function voiceSelectors() {
    const host = location.hostname;
    if (host.includes("chatgpt") || host.includes("openai")) {
      return ['button[data-testid*="voice" i]', 'button[aria-label*="voice mode" i]', 'button[aria-label*="voice" i]'];
    }
    if (host.includes("claude")) {
      return ['button[data-testid*="voice" i]', 'button[aria-label*="voice" i]', 'button[aria-label*="microphone" i]'];
    }
    if (host.includes("gemini")) {
      return ['button[aria-label*="Gemini Live" i]', 'button[aria-label*="Live" i]', 'button[aria-label*="microphone" i]', 'button[aria-label*="voice" i]'];
    }
    if (host.includes("grok")) {
      return ['button[data-testid*="voice" i]', 'button[aria-label*="voice" i]', 'button[aria-label*="talk" i]'];
    }
    if (host.includes("deepseek")) return [];
    if (host.includes("meta.ai")) {
      return ['button[aria-label*="voice" i]', 'button[aria-label*="talk" i]', 'button[data-testid*="voice" i]'];
    }
    if (host.includes("character")) {
      return ['button[aria-label*="call" i]', 'button[aria-label*="voice" i]', 'button[data-testid*="call" i]'];
    }
    if (host === "pi.ai" || host === "hey.pi.ai") {
      return ['button[aria-label*="voice" i]', 'button[aria-label*="talk" i]', 'button[aria-label*="microphone" i]'];
    }
    if (host.includes("copilot") || host.includes("poe") || host.includes("mistral") || host.includes("qwen") || host.includes("kimi")) {
      return ['button[aria-label*="voice" i]', 'button[aria-label*="microphone" i]', 'button[data-testid*="voice" i]'];
    }
    return [];
  }

  function findVoiceControl() {
    return voiceSelectors().map(safeQuery).find((el) => isElementVisible(el)) || null;
  }

  function extractModel() {
    const config = provider();
    const host = location.hostname;

    // ChatGPT no longer shows the model name in a top-bar switcher: the composer
    // pill shows the effort ("Instant") plus a model badge ("5.4") ONLY when a
    // non-default model is picked. So read the badge; its absence means the default
    // model. This is the only reliable closed-menu read for ChatGPT. Bare numbers
    // must contain a dot ("5.4", "5.10") so counters/short digits in the pill
    // can't false-positive; o-series and gpt-prefixed badges are matched whole.
    if (host.includes("chatgpt") || host.includes("openai")) {
      const pill = document.querySelector("button.__composer-pill");
      if (pill) {
        const badge = Array.from(pill.querySelectorAll("span"))
          .map((s) => cleanText(s.textContent || "").trim())
          .find((t) => /^(o\d+|\d+\.\d+(?:\s+(?:Sol|Terra|Luna))?|gpt[-\s]?\d[\w.]*(?:\s+(?:Sol|Terra|Luna))?)$/i.test(t));
        if (badge) {
          let label;
          if (/^o\d+$/i.test(badge)) label = badge.toLowerCase();
          else if (/^gpt/i.test(badge)) label = "GPT-" + badge.replace(/^gpt[-\s]?/i, "");
          else label = "GPT-" + badge;
          if (ADAPTERS?.resolveModelAlias) label = ADAPTERS.resolveModelAlias("ChatGPT", label);
          return { id: label.toLowerCase().replace(/[^a-z0-9.]+/g, "-"), label };
        }
        return config.defaultModel;
      }
    }

    // Gemini's collapsed pill shows an ABBREVIATED mode ("Flash-Lite"/"Flash"/
    // "Pro") with no version, which the version-requiring regex can't match. The
    // mode-picker button's aria-label ("…currently Flash") is the reliable source.
    // If the label ever carries a versioned name (e.g. "currently 3.5 Flash"), use
    // it directly; otherwise map the short name back to the full model label.
    // NOTE: keep this map in step with the Gemini entries in skin.js
    // PROVIDER_MODELS when Google renames or reversions models.
    if (host.includes("gemini")) {
      const btn = document.querySelector('button[aria-label*="mode picker" i]')
        || document.querySelector('button[aria-label*="currently" i]');
      const m = btn && (btn.getAttribute("aria-label") || "").match(/currently\s+(.+)$/i);
      if (m) {
        const short = m[1].trim();
        // Gemini's collapsed control omits version numbers. The July 2026
        // consumer menu identifies the generic "Flash" row as Gemini 3.5 Flash.
        const map = { "flash-lite": "Gemini 3.1 Flash-Lite", "flash": "Gemini 3.5 Flash", "pro": "Gemini 3.1 Pro" };
        const label = /\d/.test(short) ? short : (map[short.toLowerCase()] || short);
        return { id: label.toLowerCase().replace(/[^a-z0-9.]+/g, "-"), label };
      }
    }

    // Recognise current provider model names: GPT-x / o-series / Instant x.x
    // (ChatGPT), Fable/Opus/Sonnet/Haiku x.x (Claude), "x.x Flash-Lite/Flash/
    // Pro" (Gemini), and third-party names on Perplexity. Mode names (Grok
    // Fast/Auto/Expert/Heavy, DeepSeek Instant/Expert/Vision, Vibe Fast/Think/
    // Research) are deliberately NOT model names and are read separately.
    const modelPattern = /\b(GPT[-\s]?[\w.]+(?:\s+(?:Sol|Terra|Luna))?|Instant\s+\d(?:\.\d)+|o\d(?:[-\s]?\w+)?|Fable\s+[\w.]+|Opus\s+[\w.]+|Sonnet\s+[\w.]+|Haiku\s+[\w.]+|(?:Gemini\s+)?\d(?:\.\d)*\s+Flash(?:[-\s]Lite)?|(?:Gemini\s+)?\d(?:\.\d)*\s+Pro|Grok\s+\d(?:\.\d)*|DeepSeek[-\s]?V?\d(?:\.\d)*|Sonar(?:\s+\d(?:\.\d)*)?|GLM\s+\d(?:\.\d)*|Nemotron\s+\d(?:\s+Ultra)?|Muse\s+Spark|Dynamic|PipSqueak|Prime|Braniac|Brainiac|Flash|Goro|Pawly|Qwen\d(?:\.\d)*(?:[-\s](?:Max|Plus|Flash|Omni|Coder|VL|Preview|\d+B|A\d+B|\d{4}))*|(?:Kimi\s+)?K\d(?:\.\d)*(?:\s+Swarm)?)\b/i;

    // Read only from the host's model-switcher control, not arbitrary page text.
    for (const selector of modelSelectors()) {
      const el = document.querySelector(selector);
      const text = el && cleanText(el.innerText || el.textContent || "").slice(0, 80);
      const match = text && text.match(modelPattern);
      if (match) {
        let label = cleanText(match[1]).replace(/\s+/g, " ");
        if (/^Brainiac$/i.test(label)) label = "Braniac";
        const accepted = ADAPTERS?.sanitizeModelLabels
          ? ADAPTERS.sanitizeModelLabels(config.name, [label])[0]
          : label;
        if (accepted) return { id: accepted.toLowerCase().replace(/[^a-z0-9.]+/g, "-"), label: accepted };
      }
    }

    return config.defaultModel;
  }

  // Read reasoning/mode only from the closed provider picker. This avoids the
  // old full-page text scan, which confused ordinary conversation words such as
  // "high quality" for an active effort level. Operating modes (Grok, DeepSeek,
  // Vibe, Copilot) are recognized separately from reasoning levels but share
  // the same collapsed control.
  function extractEffort() {
    if (!ADAPTERS) return null;
    const texts = [];
    [...modelSelectors(), ...effortSelectors()].forEach((selector) => {
      const el = safeQuery(selector);
      if (!el || !isElementVisible(el)) return;
      const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.textContent || ""}`).slice(0, 180);
      if (text) texts.push(text);
    });
    if (location.hostname.includes("deepseek")) {
      document.querySelectorAll('[role="radio"][aria-checked="true"]').forEach((el) => {
        const text = cleanText(el.textContent || "").slice(0, 80);
        if (text) texts.unshift(text);
      });
    }
    const providerName = provider().name;
    const efforts = ADAPTERS.recognizeEfforts(providerName, texts);
    if (efforts.length) return { label: efforts[0], level: normOption(efforts[0]) };
    const modes = ADAPTERS.recognizeModes ? ADAPTERS.recognizeModes(providerName, texts) : [];
    return modes.length ? { label: modes[0], level: normOption(modes[0]), kind: "mode" } : null;
  }

  // While the model is replying, each host swaps its send button for a "stop"
  // control. That's the most reliable cross-provider "is generating" signal, so
  // we surface it to the skin to drive the thinking animation. Specific selectors
  // first, then a guarded generic fallback for when a provider's DOM shifts.
  function generatingSelectors() {
    const host = location.hostname;
    if (host.includes("chatgpt") || host.includes("openai")) {
      return ['button[data-testid="stop-button"]', 'button[aria-label="Stop streaming"]', 'button[aria-label*="stop" i]'];
    }
    if (host.includes("claude")) {
      return ['button[aria-label="Stop response"]', 'button[data-testid="stop-button"]', 'button[aria-label*="stop" i]'];
    }
    if (host.includes("gemini")) {
      return ['button[aria-label*="stop" i]', 'button.stop', 'button.send-button.stop'];
    }
    if (host.includes("grok")) {
      return ['button[aria-label*="stop" i]', 'button[data-testid*="stop" i]'];
    }
    if (host.includes("deepseek")) {
      return ['button[aria-label*="stop" i]', 'button[data-testid*="stop" i]', 'button[class*="stop" i]'];
    }
    if (host.includes("copilot") || host.includes("perplexity") || host.includes("meta.ai")
      || host.includes("character") || host.includes("poe") || host === "pi.ai" || host === "hey.pi.ai"
      || host.includes("mistral") || host.includes("qwen") || host.includes("kimi")) {
      return ['button[aria-label*="stop" i]', 'button[data-testid*="stop" i]', 'button[class*="stop" i]'];
    }
    return ['button[aria-label*="stop" i]'];
  }

  function isElementVisible(el) {
    if (!el || el.disabled || el.getAttribute("aria-disabled") === "true") return false;
    const rect = el.getBoundingClientRect();
    return rect.width > 0 && rect.height > 0;
  }

  function detectGenerating() {
    for (const selector of generatingSelectors()) {
      if (isElementVisible(safeQuery(selector))) return true;
    }
    return false;
  }

  function messageNodeSelectors() {
    const host = location.hostname;
    if (host.includes("chatgpt") || host.includes("openai")) {
      return ["[data-message-author-role]"];
    }
    if (host.includes("claude")) {
      return ['[data-testid="user-message"]', '[data-testid="assistant-message"]', ".font-claude-message"];
    }
    if (host.includes("gemini")) {
      return ["user-query", "model-response"];
    }
    if (host.includes("grok")) {
      return ['[data-message-author-role]', '[data-testid*="user-message" i]', '[data-testid*="assistant-message" i]'];
    }
    if (host.includes("deepseek")) {
      return ['[data-message-author-role]', '[data-role="user"]', '[data-role="assistant"]', '[data-testid*="user-message" i]', '[data-testid*="assistant-message" i]'];
    }
    if (host.includes("perplexity")) {
      // Perplexity renders question/answer pairs, not chat-role nodes. The
      // generic role selectors matched nothing here, which left existing
      // threads as a blank document in Shiki.
      return [
        '[data-testid="user-query"]',
        'div[class*="group/query"]',
        'h1[class*="query" i]',
        'div[id^="markdown-content-"]',
        '[data-testid="answer"]',
        '[data-message-author-role]'
      ];
    }
    if (host.includes("copilot") || host.includes("meta.ai")
      || host.includes("character") || host.includes("poe") || host === "pi.ai" || host === "hey.pi.ai"
      || host.includes("mistral") || host.includes("qwen") || host.includes("kimi")) {
      return ['[data-message-author-role]', '[data-role="user"]', '[data-role="assistant"]', '[data-testid*="user-message" i]', '[data-testid*="assistant-message" i]'];
    }
    return [];
  }

  function messageNodes() {
    let nodes = [];
    const seen = new Set();
    messageNodeSelectors().forEach((selector) => {
      try {
        Array.from(document.querySelectorAll(selector)).forEach((node) => {
          if (!seen.has(node)) {
            seen.add(node);
            nodes.push(node);
          }
        });
      } catch {
        /* ignore selector drift */
      }
    });
    if (!nodes.length) {
      nodes = Array.from(document.querySelectorAll(
        '[data-message-author-role], [data-testid="user-message"], [data-testid="assistant-message"], user-query, model-response'
      ));
    }

    return nodes;
  }

  function closestMessageNode(value) {
    const selectors = messageNodeSelectors();
    if (!selectors.length || !value) return null;
    const selector = selectors.join(", ");
    let node = value.nodeType === 1 ? value : value.parentElement;
    while (node && node.nodeType === 1) {
      try {
        if (node.matches(selector)) return node;
      } catch {
        return null;
      }
      node = node.parentElement;
    }
    return null;
  }

  function markMessageDirtyForNode(value) {
    const node = closestMessageNode(value);
    if (node) dirtyMessageNodes.add(node);
    else forceFullMessageScan = true;
  }

  function detectAuthor(node, index) {
    const role = (node.getAttribute && (
      node.getAttribute("data-message-author-role")
      || node.getAttribute("data-role")
      || node.getAttribute("data-author")
    )) || "";
    if (/user|human/i.test(role)) return "user";
    if (/assistant|bot|model|ai/i.test(role)) return "assistant";

    const tag = (node.tagName || "").toLowerCase();
    if (tag === "user-query") return "user";
    if (tag === "model-response") return "assistant";

    const hint = (node.getAttribute && (
      `${node.getAttribute("data-testid") || ""} ${node.getAttribute("id") || ""} ${node.getAttribute("class") || ""}`
    )) || "";
    if (/(^|[^a-z])(user|human|query|question)([^a-z]|$)/i.test(hint)) return "user";
    if (/assistant|model|response|answer|markdown-content|claude|gemini|bot/i.test(hint)) return "assistant";

    // Fallback: turns alternate, conventionally starting with the user.
    return index % 2 === 0 ? "user" : "assistant";
  }

  // ---- Reverse-engineer the host's rendered markdown -------------------------
  // ChatGPT/Claude/Gemini render the model's markdown into semantic HTML
  // (h1-6, p, ul/ol/li, pre/code, strong/em, a, blockquote, table, hr). We walk
  // that DOM back into a tiny, safe block/inline AST so the skin can re-render it
  // as a formatted document. The skin only ever receives this structured data and
  // builds DOM from it via textContent — raw host HTML is never forwarded.
  const BLOCK_CAP = 600; // max blocks per message (defensive)
  const RUN_CAP = 6000; // max inline runs per block (defensive)
  const MESSAGE_SCAN_TAIL_COUNT = 8;
  const MESSAGE_FULL_RECONCILE_MS = 15000;
  let blockCache = new WeakMap(); // node -> { len, blocks }; skips re-walking unchanged turns
  let messageCache = new WeakMap(); // node -> { author, richFormatting, message }
  let dirtyMessageNodes = new WeakSet();
  let forceFullMessageScan = true;
  let lastFullMessageScan = 0;
  let lastStateConversationKey = "";

  // Search inside shadow roots (Gemini and other web components often hide the
  // rendered markdown there; a flat querySelector misses it).
  function queryInTree(root, selector) {
    if (!root || !root.querySelector) return null;
    try {
      const direct = root.querySelector(selector);
      if (direct) return direct;
    } catch {
      return null;
    }
    const elements = root.querySelectorAll ? root.querySelectorAll("*") : [];
    for (const el of elements) {
      if (el.shadowRoot) {
        const found = queryInTree(el.shadowRoot, selector);
        if (found) return found;
      }
    }
    return null;
  }

  // The element holding the rendered answer, skipping surrounding host chrome.
  // Ordered most-specific → generic; matches ChatGPT's .markdown.prose, Claude's
  // message body, and Gemini's model-response content.
  const CONTENT_ROOT_SELECTORS = [
    "[data-message-content]",
    ".markdown.prose",
    ".markdown",
    ".prose",
    "[class*='markdown']",
    ".font-claude-message",
    "message-content",
    ".model-response-text",
    ".response-content",
    "article"
  ];

  function contentRoot(node) {
    for (const selector of CONTENT_ROOT_SELECTORS) {
      const found = queryInTree(node, selector);
      if (found) return found;
    }
    return node;
  }

  // Cheap structural signature so we re-parse when the host adds headings/lists/
  // code blocks during streaming even if total text length is unchanged.
  function structureFingerprint(node) {
    const root = contentRoot(node);
    const tags = ["H1", "H2", "H3", "H4", "H5", "H6", "P", "UL", "OL", "PRE", "BLOCKQUOTE", "TABLE", "HR", "CODE", "IMG"];
    let sig = "";
    tags.forEach((tag) => {
      try {
        sig += `${tag[0]}${root.querySelectorAll(tag).length},`;
      } catch {
        sig += "0,";
      }
    });
    // Bump when an out-of-band image conversion lands so memoized blocks re-walk.
    return `${sig}v${imageCacheVersion}`;
  }

  function isSkippable(el) {
    const tag = el.tagName;
    if (tag === "SVG" || tag === "BUTTON" || tag === "STYLE" || tag === "SCRIPT" || tag === "NOSCRIPT") return true;
    if (el.getAttribute("aria-hidden") === "true") return true;
    const testId = el.getAttribute("data-testid") || "";
    if (/copy|feedback|regenerate|thumb|message-actions|conversation-actions|toolbar|edit-message|branch/i.test(testId)) return true;
    const aria = el.getAttribute("aria-label") || "";
    if (/copy|regenerate|good response|bad response|edit message|read aloud/i.test(aria)) return true;
    const role = el.getAttribute("role") || "";
    if (role === "toolbar" || role === "menu") return true;
    return false;
  }

  // ---- Images ---------------------------------------------------------------
  const MIN_CONTENT_IMAGE = 48; // px; below this an <img> is treated as an icon/avatar

  // Is this <img> worth surfacing — a real content/generated image, not an icon,
  // avatar, or tiny inline glyph?
  function isContentImage(img) {
    if (!img || img.tagName !== "IMG") return false;
    const src = img.getAttribute("src") || img.currentSrc || "";
    if (!src) return false;
    if (/^data:image\/svg/i.test(src)) return false; // inline SVGs are almost always icons
    // Citation/source logos are wrapped in an <a href> to the source. They're never
    // real content (and the host renders them as tiny favicons), so drop them.
    if (img.closest("a[href]")) return false;
    const w = img.naturalWidth || img.width || parseInt(img.getAttribute("width") || "0", 10) || 0;
    const h = img.naturalHeight || img.height || parseInt(img.getAttribute("height") || "0", 10) || 0;
    if (w && h && w < MIN_CONTENT_IMAGE && h < MIN_CONTENT_IMAGE) return false;
    // Some source logos have a large natural size but the host displays them tiny
    // (e.g. a 128px publisher logo shown at 12px beside a citation). Trust the
    // on-page render size so they aren't surfaced as full-width content images.
    const rect = img.getBoundingClientRect();
    if (rect.width && rect.height && rect.width < MIN_CONTENT_IMAGE && rect.height < MIN_CONTENT_IMAGE) return false;
    if (img.closest('button, [data-testid*="avatar" i], [class*="avatar" i]')) return false;
    return true;
  }

  function dataUrlBytes(dataUrl) {
    return String(dataUrl || "").length;
  }

  function trimImageDataCache() {
    let evicted = false;
    while (imageDataCache.size > IMAGE_CACHE_MAX_ENTRIES || imageDataCacheTotalBytes > IMAGE_CACHE_MAX_BYTES) {
      const oldest = imageDataCache.keys().next().value;
      if (!oldest) break;
      imageDataCache.delete(oldest);
      imageDataCacheTotalBytes -= imageDataCacheBytes.get(oldest) || 0;
      imageDataCacheBytes.delete(oldest);
      droppedImageSources.add(oldest);
      while (droppedImageSources.size > IMAGE_CACHE_MAX_DROPPED_SOURCES) {
        droppedImageSources.delete(droppedImageSources.keys().next().value);
      }
      evicted = true;
    }
    if (imageDataCacheTotalBytes < 0) imageDataCacheTotalBytes = 0;
    if (evicted) clearMessageExtractionCache();
  }

  function cacheImageDataUrl(src, dataUrl) {
    if (!src || !/^data:image\//i.test(dataUrl)) return false;
    const bytes = dataUrlBytes(dataUrl);
    if (!bytes || bytes > IMAGE_CACHE_MAX_ITEM_BYTES) return false;
    droppedImageSources.delete(src);
    if (imageDataCache.has(src)) {
      imageDataCacheTotalBytes -= imageDataCacheBytes.get(src) || 0;
      imageDataCache.delete(src);
      imageDataCacheBytes.delete(src);
    }
    imageDataCache.set(src, dataUrl);
    imageDataCacheBytes.set(src, bytes);
    imageDataCacheTotalBytes += bytes;
    trimImageDataCache();
    return imageDataCache.has(src);
  }

  function getCachedImageDataUrl(src) {
    if (!imageDataCache.has(src)) return "";
    const dataUrl = imageDataCache.get(src);
    const bytes = imageDataCacheBytes.get(src) || dataUrlBytes(dataUrl);
    imageDataCache.delete(src);
    imageDataCacheBytes.delete(src);
    imageDataCache.set(src, dataUrl);
    imageDataCacheBytes.set(src, bytes);
    return dataUrl;
  }

  function clearImageDataCache() {
    imageDataCache.clear();
    imageDataCacheBytes.clear();
    droppedImageSources.clear();
    imageConverting.clear();
    imageDataCacheTotalBytes = 0;
    imageCacheGeneration += 1;
    imageCacheVersion += 1;
  }

  function scaledImageDimensions(width, height) {
    if (!width || !height) return { width: 0, height: 0 };
    const edgeScale = Math.min(1, IMAGE_CONVERT_MAX_EDGE / Math.max(width, height));
    const pixelScale = Math.min(1, Math.sqrt(IMAGE_CONVERT_MAX_PIXELS / (width * height)));
    const scale = Math.min(edgeScale, pixelScale);
    return {
      width: Math.max(1, Math.round(width * scale)),
      height: Math.max(1, Math.round(height * scale))
    };
  }

  // Resolve an <img> to a source the skin's CSP can render (data:/https:). blob:
  // and CORS-tainted images are converted to a data: URL out of band (see
  // convertImageToDataUrl); until that lands we return "" so they're skipped.
  function resolveImageSrc(img, raw) {
    const src = String(raw || "").trim();
    if (!src) return "";
    if (/^data:image\//i.test(src)) return dataUrlBytes(src) <= IMAGE_CACHE_MAX_ITEM_BYTES ? src : "";
    if (droppedImageSources.has(src)) return "";
    const cached = getCachedImageDataUrl(src);
    if (cached) return cached;
    if (/^https:\/\//i.test(src)) return src; // CSP allows https images directly
    if (/^blob:/i.test(src)) {
      convertImageToDataUrl(img, src);
      return "";
    }
    return ""; // http:, relative, etc. — not rendered
  }

  // Best-effort: turn a blob:/tainted image into a data: URL. Tries a same-origin
  // canvas first, then fetch(); caches the result and re-syncs so the skin shows it.
  function convertImageToDataUrl(img, src) {
    if (imageConverting.has(src) || imageDataCache.has(src) || imageConverting.size >= IMAGE_CONVERT_MAX_IN_FLIGHT) return;
    imageConverting.add(src);
    const generation = imageCacheGeneration;
    const done = (dataUrl) => {
      imageConverting.delete(src);
      if (generation !== imageCacheGeneration) return;
      if (dataUrl && cacheImageDataUrl(src, dataUrl)) {
        markMessageDirtyForNode(img);
        imageCacheVersion += 1;
        postState();
      }
    };
    try {
      const w = img.naturalWidth, h = img.naturalHeight;
      if (w && h) {
        const size = scaledImageDimensions(w, h);
        const canvas = document.createElement("canvas");
        canvas.width = size.width;
        canvas.height = size.height;
        const context = canvas.getContext("2d");
        if (!context) throw new Error("canvas-context-unavailable");
        context.drawImage(img, 0, 0, size.width, size.height);
        const url = canvas.toDataURL("image/jpeg", IMAGE_CONVERT_JPEG_QUALITY);
        if (url && url.length > 64) { done(url); return; }
      }
    } catch {
      /* tainted canvas — fall through to fetch */
    }
    try {
      const controller = new AbortController();
      const timeout = window.setTimeout(() => controller.abort(), IMAGE_CONVERT_TIMEOUT_MS);
      fetch(src, { signal: controller.signal })
        .then((response) => {
          const type = response.headers.get("content-type") || "";
          const length = Number(response.headers.get("content-length") || "0");
          if (!response.ok) throw new Error("image-fetch-failed");
          if (type && !/^image\//i.test(type)) throw new Error("not-image");
          if (length > IMAGE_CONVERT_MAX_SOURCE_BYTES) throw new Error("image-too-large");
          return response.blob();
        })
        .then((blob) => {
          if (!blob || !blob.type || !/^image\//i.test(blob.type) || blob.size > IMAGE_CONVERT_MAX_SOURCE_BYTES) {
            done("");
            return;
          }
          const reader = new FileReader();
          reader.onload = () => done(String(reader.result || ""));
          reader.onerror = () => done("");
          reader.readAsDataURL(blob);
        })
        .catch(() => done(""))
        .finally(() => window.clearTimeout(timeout));
    } catch {
      done("");
    }
  }

  // Content images within a message (generated images, user-uploaded photos),
  // de-duplicated and resolved to renderable sources.
  function collectMessageImages(node, author) {
    const root = author === "assistant" ? contentRoot(node) : node;
    let imgs = [];
    try {
      imgs = Array.from(root.querySelectorAll("img"));
    } catch {
      imgs = [];
    }
    const seen = new Set();
    const out = [];
    imgs.forEach((img) => {
      if (!isContentImage(img)) return;
      const raw = img.getAttribute("src") || img.currentSrc || "";
      const src = resolveImageSrc(img, raw);
      if (!src || seen.has(src)) return;
      seen.add(src);
      out.push({ src, alt: cleanText(img.getAttribute("alt") || "").slice(0, 200) });
    });
    return out.slice(0, 12);
  }

  // Preserve line breaks for transcript text; unlike cleanText() which collapses
  // whitespace (fine for titles, wrong for message bodies).
  function messageBodyText(node, author) {
    let root = node;
    if (author === "assistant") {
      root = contentRoot(node);
    } else {
      root = queryInTree(node, "[data-message-content], .whitespace-pre-wrap, .user-message") || node;
    }
    return String(root.innerText || root.textContent || "")
      .replace(/\u200B/g, "")
      .replace(/[ \t]+\n/g, "\n")
      .replace(/\n{3,}/g, "\n\n")
      .trim();
  }

  // Block-level tags we don't descend into while gathering a block's inline text.
  const INLINE_STOP = new Set(["UL", "OL", "PRE", "BLOCKQUOTE", "TABLE", "P", "H1", "H2", "H3", "H4", "H5", "H6", "LI"]);

  function pushInline(el, runs, marks) {
    el.childNodes.forEach((child) => {
      if (runs.length >= RUN_CAP) return;
      if (child.nodeType === 3) {
        if (child.textContent) runs.push({ ...marks, text: child.textContent });
        return;
      }
      if (child.nodeType !== 1) return;
      const tag = child.tagName;
      if (tag === "BR") { runs.push({ ...marks, text: "\n" }); return; }
      if (isSkippable(child)) return;
      // DIV/SPAN are transparent wrappers on ChatGPT/Claude (not hard stops).
      if (tag === "DIV" || tag === "SPAN") {
        pushInline(child, runs, marks);
        return;
      }
      if (INLINE_STOP.has(tag)) return;
      const next = { ...marks };
      if (tag === "STRONG" || tag === "B") next.bold = true;
      if (tag === "EM" || tag === "I") next.italic = true;
      if (tag === "CODE" || tag === "KBD" || tag === "SAMP") next.code = true;
      if (tag === "DEL" || tag === "S" || tag === "STRIKE") next.strike = true;
      if (tag === "A") {
        const href = child.getAttribute("href") || "";
        if (href) next.href = href;
      }
      pushInline(child, runs, next);
    });
  }

  // Merge adjacent runs that share the same marks.
  function mergeRuns(raw) {
    const merged = [];
    raw.forEach((run) => {
      const last = merged[merged.length - 1];
      if (last
        && !!last.bold === !!run.bold && !!last.italic === !!run.italic
        && !!last.code === !!run.code && !!last.strike === !!run.strike
        && (last.href || "") === (run.href || "")) {
        last.text += run.text;
      } else {
        merged.push({ ...run });
      }
    });
    return merged.filter((run) => run.text !== "");
  }

  // Inline runs for an element, with adjacent same-mark runs merged to stay small.
  function inlineRuns(el) {
    const raw = [];
    pushInline(el, raw, {});
    return mergeRuns(raw);
  }

  // List-item text: hosts wrap each line in <p>/<div>. Collect those as segments
  // (title line, body line) joined with a single newline; skip whitespace-only
  // text nodes that would orphan the list marker on its own line.
  function listItemRuns(li) {
    const segments = [];

    function inlineFrom(el) {
      const raw = [];
      function walkInline(node, marks) {
        node.childNodes.forEach((child) => {
          if (raw.length >= RUN_CAP) return;
          if (child.nodeType === 3) {
            const text = child.textContent.replace(/\s+/g, " ");
            if (text.trim()) raw.push({ ...marks, text });
            return;
          }
          if (child.nodeType !== 1) return;
          const tag = child.tagName;
          if (tag === "UL" || tag === "OL") return;
          if (isSkippable(child)) return;
          if (tag === "P" || tag === "DIV" || tag === "SPAN") {
            walkInline(child, marks);
            return;
          }
          const next = { ...marks };
          if (tag === "STRONG" || tag === "B") next.bold = true;
          if (tag === "EM" || tag === "I") next.italic = true;
          if (tag === "CODE" || tag === "KBD" || tag === "SAMP") next.code = true;
          if (tag === "DEL" || tag === "S" || tag === "STRIKE") next.strike = true;
          if (tag === "BR") { raw.push({ ...marks, text: "\n" }); return; }
          if (tag === "A") {
            const href = child.getAttribute("href") || "";
            if (href) next.href = href;
          }
          walkInline(child, next);
        });
      }
      walkInline(el, {});
      return mergeRuns(raw);
    }

    Array.from(li.childNodes).forEach((child) => {
      if (child.nodeType === 3) {
        const text = child.textContent.replace(/\s+/g, " ").trim();
        if (text) segments.push(mergeRuns([{ text }]));
        return;
      }
      if (child.nodeType !== 1) return;
      const tag = child.tagName;
      if (tag === "UL" || tag === "OL") return;
      if (isSkippable(child)) return;
      const runs = inlineFrom(child);
      if (runs.length) segments.push(runs);
    });

    if (!segments.length) return [];

    const raw = [];
    segments.forEach((runs, index) => {
      if (index > 0) raw.push({ text: "\n" });
      raw.push(...runs);
    });
    return mergeRuns(raw);
  }

  function listItems(listEl, depth) {
    const items = [];
    Array.from(listEl.children).forEach((li) => {
      if (li.tagName !== "LI") return;
      const runs = listItemRuns(li);
      const sublists = [];
      if (depth < 4) {
        Array.from(li.children).forEach((child) => {
          if (child.tagName === "UL" || child.tagName === "OL") {
            sublists.push({ ordered: child.tagName === "OL", items: listItems(child, depth + 1) });
          }
        });
      }
      if (runs.length || sublists.length) {
        items.push(sublists.length ? { runs, sublists } : { runs });
      }
    });
    return items;
  }

  function extractTable(tableEl) {
    const trs = Array.from(tableEl.querySelectorAll("tr")).slice(0, 80);
    if (!trs.length) return null;
    let header = null;
    const rows = [];
    trs.forEach((tr) => {
      const cells = Array.from(tr.children)
        .filter((cell) => cell.tagName === "TD" || cell.tagName === "TH")
        .slice(0, 24)
        .map((cell) => inlineRuns(cell));
      if (!cells.length) return;
      if (!header && tr.querySelector("th")) header = cells;
      else rows.push(cells);
    });
    if (!header && !rows.length) return null;
    return { type: "table", header, rows };
  }

  function collectBlocks(container, blocks, depth) {
    Array.from(container.childNodes).forEach((node) => {
      if (blocks.length >= BLOCK_CAP) return;
      if (node.nodeType === 3) {
        const text = node.textContent.replace(/\s+/g, " ").trim();
        if (text) blocks.push({ type: "p", runs: [{ text }] });
        return;
      }
      if (node.nodeType !== 1 || isSkippable(node)) return;
      const tag = node.tagName;
      if (/^H[1-6]$/.test(tag)) {
        const runs = inlineRuns(node);
        if (runs.length) blocks.push({ type: "h", level: Number(tag[1]), runs });
      } else if (tag === "P") {
        const runs = inlineRuns(node);
        if (runs.length) blocks.push({ type: "p", runs });
        // Images embedded in a paragraph (markdown ![]() output, etc.).
        Array.from(node.querySelectorAll("img")).forEach((img) => {
          if (!isContentImage(img)) return;
          const src = resolveImageSrc(img, img.getAttribute("src") || img.currentSrc || "");
          if (src) blocks.push({ type: "image", src, alt: cleanText(img.getAttribute("alt") || "").slice(0, 200) });
        });
      } else if (tag === "UL" || tag === "OL") {
        const items = listItems(node, 0);
        if (items.length) blocks.push({ type: "list", ordered: tag === "OL", items });
      } else if (tag === "PRE" || (tag === "DIV" && /code-block|codeblock/i.test(String(node.className)))) {
        const codeEl = node.querySelector("code") || node;
        const lang = (String(codeEl.className).match(/language-([\w+#.-]+)/) || [])[1] || "";
        const text = (codeEl.innerText || codeEl.textContent || "").replace(/\n$/, "");
        if (text) blocks.push({ type: "code", lang, text });
      } else if (tag === "BLOCKQUOTE") {
        const inner = [];
        collectBlocks(node, inner, depth + 1);
        if (inner.length) blocks.push({ type: "quote", blocks: inner });
      } else if (tag === "TABLE") {
        const table = extractTable(node);
        if (table) blocks.push(table);
      } else if (tag === "HR") {
        blocks.push({ type: "hr" });
      } else if (tag === "IMG") {
        if (isContentImage(node)) {
          const src = resolveImageSrc(node, node.getAttribute("src") || node.currentSrc || "");
          if (src) blocks.push({ type: "image", src, alt: cleanText(node.getAttribute("alt") || "").slice(0, 200) });
        }
      } else if (tag === "DIV" && !/code-block|codeblock/i.test(String(node.className))) {
        // Leaf paragraph divs (common on ChatGPT) — render as a single <p> instead
        // of recursing into duplicate text + wrapper blocks.
        const hasBlockChild = Array.from(node.children).some((child) =>
          child.nodeType === 1 && !isSkippable(child)
          && /^(P|UL|OL|PRE|BLOCKQUOTE|TABLE|H[1-6]|DIV|HR|IMG|FIGURE|PICTURE)$/i.test(child.tagName));
        if (!hasBlockChild) {
          const runs = inlineRuns(node);
          if (runs.length) blocks.push({ type: "p", runs });
        } else if (depth < 8) {
          collectBlocks(node, blocks, depth + 1);
        }
      } else if (depth < 8) {
        // Wrapper element (div/span/article/custom tag) — recurse for real blocks.
        collectBlocks(node, blocks, depth + 1);
      }
    });
  }

  function extractBlocks(messageNode) {
    const blocks = [];
    const root = contentRoot(messageNode);
    collectBlocks(root, blocks, 0);
    if (!blocks.length) {
      // No semantic structure (a plain reply): split on blank lines into
      // paragraphs, keeping single newlines as soft breaks.
      String(root.innerText || root.textContent || "")
        .split(/\n{2,}/)
        .forEach((para) => {
          const text = para.replace(/^\n+|\n+$/g, "");
          if (text.trim()) blocks.push({ type: "p", runs: [{ text }] });
        });
    }
    return blocks;
  }

  // Memoized per-node: only re-walk a turn when its text length or structure
  // changed (the streaming last message), so long transcripts aren't re-parsed
  // every sync.
  function blocksForNode(node) {
    const len = (node.textContent || "").length;
    const sig = structureFingerprint(node);
    const cached = blockCache.get(node);
    if (cached && cached.len === len && cached.sig === sig) return cached.blocks;
    const blocks = extractBlocks(node);
    blockCache.set(node, { len, sig, blocks });
    return blocks;
  }

  function extractMessageFromNode(node, index, knownAuthor) {
    const author = knownAuthor || detectAuthor(node, index);
    const text = messageBodyText(node, author);
    const images = collectMessageImages(node, author);
    if ((!text || text.length < 2) && !images.length) return { author, message: null };
    const message = { author, text };
    if (images.length) message.images = images;
    // Only reverse-engineer assistant turns: the hosts show user text verbatim,
    // so plain rendering preserves it (and its line breaks) best.
    if (richFormatting && author === "assistant") {
      const blocks = blocksForNode(node);
      if (blocks.length) message.blocks = blocks;
    }
    return { author, message };
  }

  function extractMessages() {
    const nodes = messageNodes().slice(-200);
    const messages = [];
    const now = Date.now();
    const fullScan = forceFullMessageScan || now - lastFullMessageScan > MESSAGE_FULL_RECONCILE_MS;
    if (fullScan) lastFullMessageScan = now;

    nodes.forEach((node, index) => {
      const author = detectAuthor(node, index);
      const tail = nodes.length - index <= MESSAGE_SCAN_TAIL_COUNT;
      const cached = messageCache.get(node);
      if (cached && !fullScan && !tail && !dirtyMessageNodes.has(node)
        && cached.author === author && cached.richFormatting === richFormatting) {
        if (cached.message) messages.push(cached.message);
        return;
      }

      const extracted = extractMessageFromNode(node, index, author);
      messageCache.set(node, {
        author: extracted.author,
        richFormatting,
        message: extracted.message
      });
      if (extracted.message) messages.push(extracted.message);
    });

    forceFullMessageScan = false;
    dirtyMessageNodes = new WeakSet();
    return messages;
  }

  function setNativeValue(element, value) {
    const prototype = element instanceof HTMLTextAreaElement
      ? HTMLTextAreaElement.prototype
      : HTMLInputElement.prototype;
    const descriptor = Object.getOwnPropertyDescriptor(prototype, "value");

    if (descriptor?.set && "value" in element) {
      descriptor.set.call(element, value);
    } else if (element.isContentEditable) {
      element.textContent = value;
    }

    element.dispatchEvent(new InputEvent("input", {
      bubbles: true,
      cancelable: true,
      data: value,
      inputType: "insertText"
    }));
  }

  // Provider-specific selectors for the composer (input) and the send button,
  // ordered most-specific → most-generic. When testers report a provider where
  // injection misses, paste the exact selector(s) from DevTools into the matching
  // host block below — putting the new one first gives it priority. The generic
  // fallbacks in findComposer()/findSendButton() still run if none of these match.
  // Last reviewed 2026-06; provider DOMs change often, so order matters more than
  // any single entry.
  function composerSelectors() {
    const host = location.hostname;
    if (host.includes("chatgpt") || host.includes("openai")) {
      return [
        "#prompt-textarea",
        '[data-testid="prompt-textarea"]',
        'div.ProseMirror[contenteditable="true"]',
        'div[contenteditable="true"][role="textbox"]'
      ];
    }
    if (host.includes("copilot") || host.includes("perplexity") || host.includes("meta.ai")
      || host.includes("character") || host.includes("poe") || host === "pi.ai" || host === "hey.pi.ai"
      || host.includes("mistral") || host.includes("qwen") || host.includes("kimi")) {
      return [
        'textarea[placeholder*="message" i]',
        'textarea[placeholder*="ask" i]',
        'textarea[placeholder*="chat" i]',
        'div[contenteditable="true"][role="textbox"]',
        '[contenteditable="true"][aria-label*="message" i]',
        'textarea'
      ];
    }
    if (host.includes("claude")) {
      return [
        'div.ProseMirror[contenteditable="true"]',
        '[contenteditable="true"][aria-label*="Claude" i]',
        'div[role="textbox"][contenteditable="true"]'
      ];
    }
    if (host.includes("gemini")) {
      return [
        'rich-textarea .ql-editor[contenteditable="true"]',
        'div.ql-editor[contenteditable="true"]',
        ".ql-editor"
      ];
    }
    if (host.includes("grok")) {
      return [
        'textarea[placeholder*="ask" i]',
        'textarea[placeholder*="message" i]',
        'div[contenteditable="true"][role="textbox"]',
        'textarea'
      ];
    }
    if (host.includes("deepseek")) {
      return [
        'textarea#chat-input',
        'textarea[placeholder*="DeepSeek" i]',
        'textarea[placeholder*="message" i]',
        'div[contenteditable="true"][role="textbox"]',
        'textarea'
      ];
    }
    return [];
  }

  function sendButtonSelectors() {
    const host = location.hostname;
    if (host.includes("chatgpt") || host.includes("openai")) {
      return [
        'button[data-testid="send-button"]',
        'button[aria-label="Send prompt"]',
        'button[aria-label*="send" i]:not([disabled])',
        'form button[type="submit"]:not([disabled])'
      ];
    }
    if (host.includes("claude")) {
      return [
        'button[aria-label="Send message" i]',
        'button[data-testid="send-button"]',
        'button[aria-label*="send" i]:not([disabled])',
        'button[type="submit"]:not([disabled])'
      ];
    }
    if (host.includes("gemini")) {
      return [
        'button.send-button',
        'button[aria-label="Send message" i]',
        'button[aria-label*="send" i]:not([disabled])',
        'button[mattooltip*="Send" i]'
      ];
    }
    if (host.includes("grok")) {
      return [
        'button[data-testid*="send" i]',
        'button[aria-label*="send" i]:not([disabled])',
        'button[type="submit"]:not([disabled])'
      ];
    }
    if (host.includes("deepseek")) {
      return [
        'button[data-testid*="send" i]',
        'button[aria-label*="send" i]:not([disabled])',
        'button[type="submit"]:not([disabled])'
      ];
    }
    if (host.includes("copilot") || host.includes("perplexity") || host.includes("meta.ai")
      || host.includes("character") || host.includes("poe") || host === "pi.ai" || host === "hey.pi.ai"
      || host.includes("mistral") || host.includes("qwen") || host.includes("kimi")) {
      return [
        'button[data-testid*="send" i]',
        'button[aria-label*="send" i]:not([disabled])',
        'button[type="submit"]:not([disabled])'
      ];
    }
    return [];
  }

  // Tolerant querySelector: a malformed tester-pasted selector returns null
  // instead of throwing and aborting the whole lookup.
  function safeQuery(selector) {
    try {
      return document.querySelector(selector);
    } catch {
      return null;
    }
  }

  function findComposer() {
    // Provider-specific first, then generic fallbacks that work across hosts.
    for (const selector of composerSelectors()) {
      const el = safeQuery(selector);
      if (el) return el;
    }
    return safeQuery("textarea")
      || safeQuery('[contenteditable="true"]')
      || safeQuery('[role="textbox"]');
  }

  // A button is clickable only if it's neither natively disabled nor marked
  // aria-disabled (some hosts gray out send with aria-disabled rather than the
  // disabled property). Returning only clickable buttons lets submitPrompt poll
  // cleanly until the host actually enables send.
  function isClickable(el) {
    return !!el && !el.disabled && el.getAttribute("aria-disabled") !== "true";
  }

  function findSendButton() {
    // Provider-specific first; only return an *enabled* button so submitPrompt
    // keeps polling (rather than clicking a dead button) until send is ready.
    for (const selector of sendButtonSelectors()) {
      const el = safeQuery(selector);
      if (isClickable(el)) return el;
    }
    const generic = safeQuery('[data-testid="send-button"]');
    if (isClickable(generic)) return generic;
    const labelled = safeQuery('button[aria-label*="send" i]');
    if (isClickable(labelled)) return labelled;
    return Array.from(document.querySelectorAll("button")).find((button) =>
      /send|submit/i.test(button.getAttribute("aria-label") || button.textContent || "") && isClickable(button)) || null;
  }

  // Current text held by a composer, normalized for comparison. Works for both
  // <textarea>/<input> (value) and contenteditable editors (textContent).
  function composerText(input) {
    if (!input) return "";
    const raw = input.value != null ? input.value : (input.textContent || "");
    return String(raw).replace(/\u200B/g, "").trim();
  }

  function pressEnter(input) {
    // A full keydown→keypress→keyup sequence is more likely to be honored by
    // editors that submit on Enter than a lone keydown.
    ["keydown", "keypress", "keyup"].forEach((type) => {
      input.dispatchEvent(new KeyboardEvent(type, {
        key: "Enter",
        code: "Enter",
        keyCode: 13,
        which: 13,
        bubbles: true,
        cancelable: true
      }));
    });
  }

  function insertComposerText(input, text) {
    input.focus();

    if (input.isContentEditable) {
      // Provider editors (ProseMirror, Lexical, Quill, and textarea variants) track their
      // own document model, so plain textContent assignment is ignored.
      // execCommand dispatches real beforeinput/input events the editor listens
      // for, which is also what flips the send button from disabled → enabled.
      const selection = window.getSelection();
      selection.removeAllRanges();
      const range = document.createRange();
      range.selectNodeContents(input);
      selection.addRange(range);
      if (range.toString()) document.execCommand("delete", false);
      const inserted = document.execCommand("insertText", false, text);
      // Some editors reject execCommand; fall back to a manual input event.
      if (!inserted || !composerText(input)) {
        input.textContent = text;
        input.dispatchEvent(new InputEvent("input", {
          bubbles: true,
          cancelable: true,
          data: text,
          inputType: "insertText"
        }));
      }
    } else {
      setNativeValue(input, text);
    }
  }

  // Cheap count of rendered conversation turns. Used as a positive "it sent"
  // signal: if it grows after we dispatch, the message definitely landed — even
  // when the composer is unreadable because the host swapped it out.
  function messageTurnCount() {
    try {
      return messageNodes().length;
    } catch {
      return 0;
    }
  }

  // ---- Outbound photo attachments -------------------------------------------
  // Rebuild a File from the data: URL the skin sent so we can hand it to the host.
  function dataUrlToFile(dataUrl, name, type) {
    try {
      const comma = String(dataUrl).indexOf(",");
      if (comma < 0) return null;
      const meta = dataUrl.slice(0, comma);
      const b64 = dataUrl.slice(comma + 1);
      const mime = type || (meta.match(/data:([^;]+)/) || [])[1] || "image/png";
      const binary = atob(b64);
      const bytes = new Uint8Array(binary.length);
      for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
      return new File([bytes], name || "image.png", { type: mime });
    } catch {
      return null;
    }
  }

  // Host file-input selectors, most-specific → generic. Paste verified ones here.
  function hostFileInputSelectors() {
    const host = location.hostname;
    if (host.includes("chatgpt") || host.includes("openai")) {
      return ['input[type="file"][accept*="image" i]', 'input[type="file"][multiple]', 'input[type="file"]'];
    }
    if (host.includes("claude")) {
      return ['input[data-testid="file-upload-input"]', 'input[type="file"][accept*="image" i]', 'input[type="file"]'];
    }
    if (host.includes("gemini")) {
      return ['input[type="file"][accept*="image" i]', 'input[type="file"]'];
    }
    if (host.includes("grok")) {
      return ['input[type="file"][accept*="image" i]', 'input[type="file"]'];
    }
    if (host.includes("deepseek")) {
      return ['input[type="file"][accept*="image" i]', 'input[type="file"][accept*="pdf" i]', 'input[type="file"]'];
    }
    return ['input[type="file"]'];
  }

  function attachViaFileInput(files) {
    for (const selector of hostFileInputSelectors()) {
      let input = null;
      try {
        input = document.querySelector(selector);
      } catch {
        input = null;
      }
      if (!input) continue;
      try {
        const data = new DataTransfer();
        files.forEach((file) => data.items.add(file));
        input.files = data.files;
        input.dispatchEvent(new Event("change", { bubbles: true }));
        input.dispatchEvent(new Event("input", { bubbles: true }));
        return true;
      } catch {
        /* malformed selector / read-only files — try the next one */
      }
    }
    return false;
  }

  function attachViaDrop(files) {
    const target = findComposer();
    if (!target) return false;
    try {
      const data = new DataTransfer();
      files.forEach((file) => data.items.add(file));
      ["dragenter", "dragover", "drop"].forEach((type) => {
        target.dispatchEvent(new DragEvent(type, { bubbles: true, cancelable: true, dataTransfer: data }));
      });
      return true;
    } catch {
      return false;
    }
  }

  // Inject staged photos into the host composer: try the host's file input first
  // (most reliable), then fall back to a synthetic drag-and-drop onto the editor.
  function attachImagesToComposer(images) {
    const files = (images || [])
      .map((image) => dataUrlToFile(image.dataUrl, image.name, image.type))
      .filter(Boolean);
    if (!files.length) return false;
    if (attachViaFileInput(files)) return true;
    return attachViaDrop(files);
  }

  function submitPrompt(text, images) {
    const hasImages = Array.isArray(images) && images.length > 0;
    if (hasImages) attachImagesToComposer(images);

    const input = findComposer();
    if (!input) return false;

    const target = String(text || "").trim();
    if (!target && !hasImages) return false;

    if (target) insertComposerText(input, text);

    const needle = target.slice(0, 24);
    const baselineTurns = messageTurnCount();
    // The single biggest reason a message "doesn't go through": we click send (or
    // press Enter) before the host framework has registered the injected text and
    // enabled its send button. So poll for an *enabled* send button, clicking the
    // moment one appears, and only fall back to a synthetic Enter if none shows.
    const start = Date.now();
    // Photo uploads keep the host's send button disabled until processing finishes,
    // so give attachments a much longer window to become sendable.
    const SEND_DEADLINE_MS = hasImages ? 15000 : 3000;
    let dispatched = false;

    // Treat the message as sent if ANY reliable signal says so. Reading only the
    // originally-captured composer node was the main source of false "may not
    // have sent" warnings: after a send the host often re-renders or navigates
    // (e.g. the first message in a new chat goes / -> /c/<id>), detaching that
    // node while it still holds the old text. So we also check that it's still in
    // the DOM, re-query the *live* composer, and watch the turn count grow.
    function sent() {
      if (input && !input.isConnected) return true;
      if (messageTurnCount() > baselineTurns) return true;
      const live = findComposer() || input;
      return !composerText(live).includes(needle);
    }

    function confirmSend() {
      const deadline = Date.now() + (hasImages ? 16000 : 3500);
      let retried = false;
      (function poll() {
        if (sent()) {
          notifySkin("submit-result", { ok: true });
          postState();
          return;
        }
        if (Date.now() < deadline) {
          // One self-guarding re-dispatch if the live composer still holds our
          // text well after the first attempt. Clicking an *enabled* send button
          // is safe against duplicates: once the message goes out the button
          // disables, so a late click is a no-op. Enter is only a last resort.
          if (!retried && Date.now() - start > 1100) {
            retried = true;
            const button = findSendButton();
            if (isClickable(button)) {
              button.click();
            } else {
              const live = findComposer();
              if (live && live.isConnected) pressEnter(live);
            }
          }
          window.setTimeout(poll, 200);
          return;
        }
        notifySkin("submit-result", { ok: false, reason: "send-failed" });
      })();
    }

    function tryClickOrRetry() {
      if (dispatched) return;
      const sendButton = findSendButton();
      if (isClickable(sendButton)) {
        sendButton.click();
        dispatched = true;
        confirmSend();
        return;
      }
      if (Date.now() - start < SEND_DEADLINE_MS) {
        // If the editor dropped our draft (focus churn resets some editors),
        // re-assert it into the live composer before the next attempt.
        const live = findComposer() || input;
        if (target && live && live.isConnected && !composerText(live)) insertComposerText(live, text);
        window.setTimeout(tryClickOrRetry, 120);
        return;
      }
      // No enabled send button ever appeared — last resort is Enter.
      pressEnter(input);
      dispatched = true;
      confirmSend();
    }

    window.setTimeout(tryClickOrRetry, 50);
    return true;
  }

  function conversationCacheKey(conversation) {
    return [
      location.origin,
      location.pathname,
      conversation?.id || "",
      conversation?.href || ""
    ].join("|");
  }

  function clearMessageExtractionCache() {
    blockCache = new WeakMap();
    messageCache = new WeakMap();
    dirtyMessageNodes = new WeakSet();
    forceFullMessageScan = true;
    lastFullMessageScan = 0;
  }

  function resetCachesForConversation(conversation) {
    const key = conversationCacheKey(conversation);
    if (key === lastStateConversationKey) return;
    lastStateConversationKey = key;
    clearImageDataCache();
    clearMessageExtractionCache();
  }

  function capabilityHintTexts() {
    const selectors = [
      '[data-testid*="account" i]',
      '[data-testid*="profile" i]',
      'button[aria-label*="account" i]',
      'button[aria-label*="profile" i]',
      'button[aria-label*="settings" i]',
      'button[aria-label*="deepthink" i]',
      'button[data-testid*="deepthink" i]',
      'a[href*="subscription" i]',
      'a[href*="billing" i]'
    ];
    const values = [];
    const explicitPlans = [];
    selectors.forEach((selector) => {
      try {
        document.querySelectorAll(selector).forEach((el) => {
          const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.textContent || ""}`).slice(0, 160);
          if (text) values.push(text);
        });
      } catch {
        /* selector drift */
      }
    });

    // Some providers (currently Claude) render the subscription label inside a
    // profile button without a stable account/profile attribute. Read only
    // short, visible controls that explicitly contain "… plan" so effort rows
    // such as plain "Max" cannot be mistaken for an account tier. These raw
    // strings are used in-memory for inference and are never persisted.
    const explicitPlanPattern = /\b(?:free|go|plus|pro|max|ai\s+plus|ai\s+pro|ai\s+ultra|supergrok(?:\s+(?:lite|heavy))?)\s+plan\b/i;
    try {
      document.querySelectorAll('button, [role="button"], [data-testid*="plan" i], [class*="plan" i]').forEach((el) => {
        if (!isElementVisible(el)) return;
        const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.innerText || el.textContent || ""}`).slice(0, 160);
        if (explicitPlanPattern.test(text)) explicitPlans.push(text);
      });
    } catch {
      /* selector drift */
    }

    // Some account buttons expose a plain tier ("Example User · Free") rather than the
    // phrase "Free plan". Accessibility names can be computed from descendants,
    // so inspect short visible controls as well as aria-labelled selectors, but
    // require an account/profile marker before accepting a bare tier word.
    const accountMarkerPattern = /\b(?:account|profile|open profile menu)\b/i;
    const plainTierPattern = /\b(?:supergrok\s+(?:heavy|lite)|ai\s+(?:ultra|pro|plus)|free|go|plus|pro|max)\b/i;
    try {
      document.querySelectorAll('button, [role="button"]').forEach((el) => {
        if (!isElementVisible(el)) return;
        const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.getAttribute("title") || ""} ${el.innerText || el.textContent || ""}`).slice(0, 160);
        if (!accountMarkerPattern.test(text)) return;
        const tier = text.match(plainTierPattern)?.[0];
        if (tier) explicitPlans.push(`${tier} plan`);
      });
    } catch {
      /* selector drift */
    }
    // Put direct plan evidence first so a provider's many generic profile or
    // settings controls cannot push it past the bounded inference input.
    return Array.from(new Set([...explicitPlans, ...values])).slice(0, 40);
  }

  function capabilitySurfaceElements() {
    const selectors = [
      '[role="menuitem"]',
      '[role="menuitemradio"]',
      '[role="option"]',
      '[role="radio"]',
      '[role="switch"]',
      '[role="menu"] button',
      '[role="menu"] [tabindex]',
      '[role="dialog"] button',
      '[role="listbox"] button'
    ];
    const seen = new Set();
    const elements = [];
    selectors.forEach((selector) => {
      try {
        document.querySelectorAll(selector).forEach((el) => {
          if (!seen.has(el) && isElementVisible(el)) {
            seen.add(el);
            elements.push(el);
          }
        });
      } catch {
        /* selector drift */
      }
    });

    // Claude's current Base UI model rows expose useful accessibility actions
    // without consistently carrying role/tabindex attributes in the DOM. Once a
    // known popup surface is open, include its short visible descendants too.
    // Clicking a text descendant bubbles to the provider's row handler, while
    // keeping discovery scoped to the popup avoids matching chat/sidebar text.
    const surfaceRoots = [
      '[role="menu"]',
      '[role="listbox"]',
      '[role="dialog"]',
      '[popover]:popover-open',
      '[data-radix-popper-content-wrapper]',
      '[data-base-ui-portal]',
      '[data-side][data-align]',
      '.cdk-overlay-pane',
      '.ant-dropdown',
      '.ant-select-dropdown',
      // Kimi's current Vue/Naive UI picker is a custom popup with no menu,
      // listbox, option, or dialog roles. Keep these exact provider-owned
      // content classes in the same bounded-popup path as semantic menus so
      // visible K3/K3 Swarm rows are captured without scanning page copy.
      '.n-popover__content.models-popover',
      '.n-popover__content.effort-popover'
    ];
    const scanRoot = (root) => {
      if (!root || !isElementVisible(root)) return;
      root.querySelectorAll("*").forEach((el) => {
        if (seen.has(el) || !isElementVisible(el) || el.children.length > 4) return;
        const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.innerText || el.textContent || ""}`);
        if (!text || text.length > 220) return;
        seen.add(el);
        elements.push(el);
      });
    };
    surfaceRoots.forEach((selector) => {
      try {
        document.querySelectorAll(selector).forEach(scanRoot);
      } catch {
        /* selector drift */
      }
    });

    // A promoted/entitlement row may be a sibling of the semantic menu rather
    // than a descendant of it. Starting from confirmed visible options, climb to
    // the first bounded floating container and scan that popup as one surface.
    // This captures Claude's Fable card while staying away from the page body.
    elements.slice().forEach((seed) => {
      let ancestor = seed.parentElement;
      for (let depth = 0; ancestor && depth < 7; depth += 1, ancestor = ancestor.parentElement) {
        const style = window.getComputedStyle(ancestor);
        const rect = ancestor.getBoundingClientRect();
        const floating = /^(?:absolute|fixed|sticky)$/.test(style.position);
        const bounded = rect.width > 80 && rect.height > 40
          && rect.width < window.innerWidth * 0.8 && rect.height < window.innerHeight * 0.9;
        if (floating && bounded) {
          scanRoot(ancestor);
          break;
        }
      }
    });
    return elements;
  }

  // Popup containers that indicate an actually-open menu. Persistent page
  // controls (ChatGPT's always-visible Chat/Work radios, composer switches)
  // match the broad role selectors above but must never count as an open
  // menu: they made open-detection report "menu mounted" while the real menu
  // was still closed, which broke both scanning and switching on ChatGPT.
  const MENU_CONTAINER_SELECTOR = '[role="menu"], [role="listbox"], [role="dialog"], [popover], [data-radix-popper-content-wrapper], [data-base-ui-portal], .cdk-overlay-pane, [data-side][data-align], .ant-dropdown, .ant-select-dropdown, .n-popover__content.models-popover, .n-popover__content.effort-popover';
  const MENU_ITEM_ROLE_PATTERN = /^(?:menuitem|menuitemradio|menuitemcheckbox|option)$/i;

  function dialogContainsCapabilityOptions(dialog) {
    if (!dialog || dialog.getAttribute("role") !== "dialog") return true;
    const heading = dialog.querySelector('[aria-label], h1, h2, h3, [role="heading"]');
    const name = cleanText(`${dialog.getAttribute("aria-label") || ""} ${heading?.textContent || ""}`).slice(0, 240);
    // Persistent consent/auth prompts can coexist with the composer. They are
    // not evidence that clicking a model control opened a capability surface.
    if (/\b(?:cookie policy|cookie preferences|privacy choices|consent preferences)\b|^(?:sign|log)\s+in\b|^create (?:an )?account\b/i.test(name)) {
      return false;
    }
    const text = cleanText(`${name} ${dialog.innerText || dialog.textContent || ""}`).slice(0, 2400);
    if (ADAPTERS?.capabilityEvidenceForText) {
      return ADAPTERS.capabilityEvidenceForText(provider().name, text);
    }
    return /\b(?:models?|bots?|chat styles?|thinking effort|reasoning)\b/i.test(text);
  }

  function isMenuSurfaceElement(el) {
    if (!el || el.nodeType !== 1) return false;
    try {
      const container = el.closest(MENU_CONTAINER_SELECTOR);
      if (container) {
        if (container.getAttribute("role") === "dialog" && !dialogContainsCapabilityOptions(container)) return false;
        return true;
      }
      if (!MENU_ITEM_ROLE_PATTERN.test(el.getAttribute("role") || "")) return false;
      // A few custom menus put the item role on the floating row without a
      // semantic container. Accept it only inside a bounded floating ancestor;
      // persistent sidebar menuitems must not make a closed picker look open.
      let ancestor = el;
      for (let depth = 0; ancestor && depth < 6; depth += 1, ancestor = ancestor.parentElement) {
        const style = window.getComputedStyle(ancestor);
        const rect = ancestor.getBoundingClientRect();
        if (/^(?:absolute|fixed)$/.test(style.position)
          && rect.width > 60 && rect.height > 24
          && rect.width < window.innerWidth * 0.9 && rect.height < window.innerHeight * 0.95) return true;
      }
      return false;
    } catch {
      return false;
    }
  }

  // Only elements belonging to an open popup — used for open-detection,
  // option matching, and menu settling.
  function menuSurfaceElements() {
    return capabilitySurfaceElements().filter(isMenuSurfaceElement);
  }

  function surfaceTexts() {
    return menuSurfaceElements()
      .map((el) => surfaceOptionText(`${el.getAttribute("aria-label") || ""} ${el.textContent || ""}`).slice(0, 220))
      .filter(Boolean);
  }

  // Some hosts (DeepSeek) render their mode picker and feature toggles as
  // inline styled spans with hashed classes — no buttons, roles, or ARIA. Read
  // short clickable text chips near the composer so those controls are still
  // detected without opening any menu.
  function inlineControlTexts() {
    if (!location.hostname.includes("deepseek")) return [];
    const texts = [];
    try {
      document.querySelectorAll("span, div").forEach((el) => {
        if (texts.length >= 40 || !isElementVisible(el) || el.children.length > 2) return;
        const text = cleanText(el.textContent || "");
        if (!text || text.length > 24) return;
        const clickable = getComputedStyle(el).cursor === "pointer"
          || !!el.closest('[role="button"], button, [class*="btn" i]');
        if (clickable) texts.push(text);
      });
    } catch {
      /* selector drift */
    }
    return ADAPTERS ? ADAPTERS.unique(texts) : Array.from(new Set(texts));
  }

  function dynamicSurfaceOptions(providerName) {
    if (providerName !== "Poe") return [];
    const disallowed = /^(?:search|explore|create|new chat|new bot|manage|settings|cancel|close|more|bots?|models?)$/i;
    const labels = menuSurfaceElements()
      .filter((el) => /^(?:option|menuitem|menuitemradio)$/i.test(el.getAttribute("role") || ""))
      .map((el) => {
        const raw = el.getAttribute("aria-label") || el.innerText || el.textContent || "";
        return raw.split(/\r?\n/).map(surfaceOptionText).find(Boolean) || "";
      })
      .filter((label) => label.length > 1 && label.length <= 80 && !disallowed.test(label));
    return ADAPTERS ? ADAPTERS.unique(labels) : Array.from(new Set(labels));
  }

  function baseCapabilities() {
    const config = provider();
    const current = extractModel();
    const trigger = modelSelectors().map(safeQuery).find((el) => isElementVisible(el));
    const secondaryTrigger = effortSelectors().map(safeQuery).find((el) => isElementVisible(el));
    const nativePrimary = !!trigger || !!inlinePrimaryControl();
    const texts = capabilityHintTexts();
    const models = current?.label ? [current.label] : [];
    const capabilities = {
      provider: config.name,
      schemaVersion: CAPABILITY_SCHEMA_VERSION,
      extensionVersion: EXTENSION_VERSION,
      routeFamily: routeFamily(),
      selectorKind: ADAPTERS?.PROVIDERS?.[config.name]?.selectorKind || "model",
      selectorLabel: ADAPTERS?.PROVIDERS?.[config.name]?.selectorLabel || "model",
      scanned: false,
      // A visible native control keeps the selector usable even before any
      // option list is verified; an unknown plan never disables anything.
      nativeControl: nativePrimary,
      modelsVerified: false,
      modesVerified: false,
      effortsVerified: false,
      togglesVerified: false,
      surfacesVerified: false,
      primaryOptionsVerified: false,
      optionsVerified: false,
      modelSelector: nativePrimary,
      effortSelector: !!secondaryTrigger || !!inlinePrimaryControl(),
      models,
      modes: [],
      efforts: [],
      toggles: [],
      toggleStates: {},
      modelBadges: {},
      activeMode: "",
      surfaces: [],
      activeSurface: "",
      voiceAvailable: !!findVoiceControl(),
      texts,
      plan: { label: "Detecting…", confidence: "low", source: "pending" },
      updatedAt: Date.now()
    };
    if (!nativePrimary && ADAPTERS) capabilities.plan = ADAPTERS.inferPlan(config.name, capabilities);
    // Raw menu/account text is needed only for inference and may contain an email
    // or display name. Never send or persist it in Shiki's capability snapshot.
    delete capabilities.texts;
    return capabilities;
  }

  // Poll for a menu/portal surface to actually mount before reading options,
  // instead of a single fixed delay: portals render asynchronously and at
  // different speeds per host.
  async function waitForSurface(maxMs = 900, baseline = null) {
    const changedFromBaseline = () => {
      const current = menuSurfaceElements();
      if (!baseline) return current.length > 0;
      const currentSet = new Set(current);
      if (current.some((el) => !baseline.elements.has(el))) return true;
      if (Array.from(baseline.elements).some((el) => !currentSet.has(el))) baseline.sawRemoval = true;
      // If a menu was already open, clicking its trigger closes it; reopening
      // may reuse the exact same DOM nodes. A witnessed removal followed by a
      // reappearance is therefore valid post-click evidence too.
      return baseline.sawRemoval && current.some((el) => baseline.elements.has(el));
    };
    const start = Date.now();
    while (Date.now() - start < maxMs) {
      if (changedFromBaseline()) {
        await waitForDom(120); // let the mounted surface settle
        return true;
      }
      await waitForDom(60);
    }
    return changedFromBaseline();
  }

  function menuScrollContainers() {
    const found = [];
    const seen = new Set();
    try {
      document.querySelectorAll(MENU_CONTAINER_SELECTOR).forEach((root) => {
        if (root.getAttribute("role") === "dialog" && !dialogContainsCapabilityOptions(root)) return;
        [root, ...root.querySelectorAll("*")].forEach((el) => {
          if (seen.has(el) || !isElementVisible(el)) return;
          if (el.scrollHeight <= el.clientHeight + 4 || el.clientHeight < 40) return;
          const overflow = window.getComputedStyle(el).overflowY;
          if (!/(?:auto|scroll)/i.test(overflow)) return;
          seen.add(el);
          found.push(el);
        });
      });
    } catch {
      /* selector drift */
    }
    return found;
  }

  // Walk virtualized/scrolling option lists without selecting anything. Each
  // viewport is captured after the host has had a moment to mount its rows, then
  // the original scroll position is restored. `complete` is false if a menu was
  // too large to reach its end within the safety bound.
  async function captureMenuPages(capture, maxPages = 18) {
    let complete = true;
    for (const container of menuScrollContainers()) {
      const original = container.scrollTop;
      container.scrollTop = 0;
      await waitForDom(70);
      capture();
      let pages = 0;
      while (pages < maxPages) {
        const end = Math.max(0, container.scrollHeight - container.clientHeight);
        if (container.scrollTop >= end - 2) break;
        const next = Math.min(end, container.scrollTop + Math.max(120, Math.floor(container.clientHeight * 0.8)));
        if (next <= container.scrollTop + 1) break;
        container.scrollTop = next;
        await waitForDom(70);
        capture();
        pages += 1;
      }
      if (container.scrollTop < container.scrollHeight - container.clientHeight - 2) complete = false;
      container.scrollTop = Math.min(original, Math.max(0, container.scrollHeight - container.clientHeight));
      await waitForDom(40);
    }
    return complete;
  }

  // Switch/radio rows with a machine-readable checked state. Text alone can't
  // distinguish "Extended on" from "Extended off"; this reads the actual
  // aria-checked / aria-pressed / data-state semantics.
  function surfaceToggleEntries() {
    const entries = [];
    const seen = new Set();
    const collect = (el) => {
      if (!el || seen.has(el) || !isElementVisible(el)) return;
      const state = el.getAttribute("aria-checked")
        ?? el.getAttribute("aria-pressed")
        ?? el.getAttribute("aria-selected")
        ?? (el.getAttribute("data-state") === "checked" ? "true"
          : el.getAttribute("data-state") === "unchecked" ? "false"
            : el.getAttribute("data-state") === "active" ? "true"
              : el.getAttribute("data-state") === "inactive" ? "false" : null);
      if (state !== "true" && state !== "false") return;
      const row = el.closest('[role="menuitem"], [role="menuitemradio"], [role="menuitemcheckbox"], [role="option"], label') || el;
      const text = cleanText(`${row.getAttribute("aria-label") || ""} ${el.getAttribute("aria-label") || ""} ${row.textContent || ""}`).slice(0, 200);
      if (!text) return;
      seen.add(el);
      entries.push({ text, checked: state === "true" });
    };
    try {
      document.querySelectorAll('[role="switch"], [role="menuitemradio"], [role="menuitemcheckbox"], [role="radio"], [role="tab"], [aria-checked], [aria-pressed], [aria-selected]').forEach(collect);
    } catch {
      /* selector drift */
    }
    return entries;
  }

  // Surface navigation is often a tab/link row rather than a switch. Capture
  // both selected and unselected entries so availability and active state are
  // independent (Vibe tabs and Kimi's sidebar are current examples).
  function surfaceControlEntries() {
    const config = ADAPTERS?.PROVIDERS?.[provider().name] || {};
    const labels = (config.surfaces || []).map((value) => typeof value === "string" ? value : value?.label).filter(Boolean);
    if (!labels.length) return [];
    const compact = (value) => String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "");
    const entries = [];
    const seen = new Set();
    const matchesSurface = (text) => labels.some((label) => {
      const haystack = compact(text);
      const needle = compact(label);
      return haystack === needle || haystack === `${needle}beta`;
    });
    try {
      document.querySelectorAll('[role="tab"], [aria-current], nav a, nav button, aside a, aside button').forEach((el) => {
        if (seen.has(el) || !isElementVisible(el)) return;
        const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.textContent || ""}`).slice(0, 100);
        if (!matchesSurface(text)) return;
        const checked = el.getAttribute("aria-selected") === "true"
          || el.getAttribute("aria-checked") === "true"
          || el.getAttribute("aria-current") === "page"
          || el.getAttribute("data-state") === "active";
        seen.add(el);
        entries.push({ text, checked });
      });
    } catch {
      /* selector drift */
    }
    if (provider().name === "Kimi") {
      const path = location.pathname.toLowerCase();
      const routeSurface = path.startsWith("/code") ? "Kimi Code"
        : path.includes("kimi-work") ? "Kimi Work"
          : path.includes("claw") ? "Kimi Claw"
            : /^\/$/.test(path) ? "Chat" : "";
      entries.forEach((entry) => {
        if (routeSurface && compact(entry.text).startsWith(compact(routeSurface))) entry.checked = true;
      });
      if (document.querySelector('.chat-editor, [href*="new_chat"]')) {
        entries.push({ text: "Chat", checked: routeSurface === "Chat" });
      }
    }
    return entries;
  }

  function waitForDom(ms) {
    return new Promise((resolve) => window.setTimeout(resolve, ms));
  }

  function concealNativeControls() {
    nativeControlMaskDepth += 1;
    document.documentElement.classList.add(NATIVE_CONTROL_MASK_CLASS);
  }

  function revealNativeControls() {
    nativeControlMaskDepth = Math.max(0, nativeControlMaskDepth - 1);
    if (!nativeControlMaskDepth) document.documentElement.classList.remove(NATIVE_CONTROL_MASK_CLASS);
  }

  function settleNativeControlInteraction(trigger) {
    closeCapabilitySurface(trigger).finally(revealNativeControls);
  }

  async function closeCapabilitySurface(trigger) {
    const escapeOptions = { key: "Escape", code: "Escape", bubbles: true };
    if (document.activeElement && document.activeElement !== document.body) {
      document.activeElement.dispatchEvent(new KeyboardEvent("keydown", escapeOptions));
    }
    document.dispatchEvent(new KeyboardEvent("keydown", escapeOptions));
    await waitForDom(60);
    // Only re-click when an actual popup is still mounted; persistent page
    // radios must not make this toggle the menu straight back open.
    if (menuSurfaceElements().length && trigger?.isConnected) {
      trigger.click();
      await waitForDom(80);
    }
  }

  async function discoverCapabilities(force = false) {
    if (capabilityScanPromise) return capabilityScanPromise;
    if (!isSupportedRoute()) return detectedCapabilities || baseCapabilities();
    if (!force && detectedCapabilities && Date.now() - lastCapabilityScan < CAPABILITY_REFRESH_MS) {
      cacheStats.hits += 1;
      return detectedCapabilities;
    }
    cacheStats.misses += 1;
    if (detectGenerating()) return detectedCapabilities || baseCapabilities();

    concealNativeControls();
    const scanStartedAt = Date.now();
    capabilityScanPromise = (async () => {
      const config = provider();
      const current = extractModel();
      const trigger = modelSelectors().map(safeQuery).find((el) => isElementVisible(el));
      const secondaryTrigger = effortSelectors().map(safeQuery).find((el) => isElementVisible(el));
      const nativePrimary = !!trigger || !!inlinePrimaryControl();
      const secondaryControlSeparate = !!secondaryTrigger && secondaryTrigger !== trigger;
      if (nativePrimary) earlyScanRetries = 0;

      // Early after navigation the SPA may not have hydrated its picker yet.
      // Don't cache a false "no native control" for the whole TTL — return an
      // unscanned snapshot and retry with backoff while the page settles.
      if (!nativePrimary && earlyScanRetries < 6 && Date.now() - routeHydrationStartedAt < 15000) {
        earlyScanRetries += 1;
        window.setTimeout(() => discoverCapabilities(true), 700 + earlyScanRetries * 300);
        return detectedCapabilities || baseCapabilities();
      }

      const accountTexts = capabilityHintTexts();
      const texts = [...accountTexts];
      const dynamicOptions = [];
      const toggleEntries = [];
      const sharedConfig = ADAPTERS?.PROVIDERS?.[config.name] || {};
      let rootMenuOpened = false;
      let rootMenuComplete = false;
      let modelSubmenuRequired = false;
      let effortSubmenuRequired = false;
      let modelSubmenuOpened = false;
      let effortSubmenuOpened = false;
      let modelSubmenuComplete = false;
      let effortSubmenuComplete = false;
      let secondaryMenuOpened = false;
      let secondaryMenuComplete = false;

      const captureSurface = () => {
        texts.push(...surfaceTexts());
        dynamicOptions.push(...dynamicSurfaceOptions(config.name));
        toggleEntries.push(...surfaceToggleEntries());
      };

      // Toggles rendered outside menus (e.g. a DeepThink pill in the composer)
      // carry state even before any menu is opened, and inline chip controls
      // (DeepSeek's Instant/Expert/Vision) never appear in a menu at all.
      toggleEntries.push(...surfaceToggleEntries());
      toggleEntries.push(...surfaceControlEntries());
      const inlineTexts = inlineControlTexts();
      texts.push(...inlineTexts);

      // Hosts disagree on what opens their picker: Gemini's Material button
      // needs a real click, while ChatGPT's Radix pill ignores synthetic
      // click() and only opens on pointer events. Try click first, then fall
      // back to the pointer/hover family. (This mismatch is why earlier
      // releases saw "no options" on ChatGPT and disabled the selector.)
      const openControl = async (control) => {
        if (!control) return false;
        const baseline = { elements: new Set(menuSurfaceElements()), sawRemoval: false };
        control.click();
        // Menus that honor click() mount fast; fall back to pointer events
        // (ChatGPT's Radix pill) quickly instead of waiting out a long window.
        if (await waitForSurface(260, baseline)) return true;
        hoverOpen(control);
        return waitForSurface(500, baseline);
      };
      const openTrigger = () => openControl(trigger);

      if (trigger) {
        // Menus render into portals asynchronously; wait for the surface to
        // mount rather than sampling at a fixed delay.
        rootMenuOpened = await openTrigger();
        if (rootMenuOpened) captureSurface();
        // Promotional/entitlement rows can arrive one render after the core
        // options (Claude's Fable row is a current example). Require two stable
        // observations and allow a longer bounded window for entitlement data.
        let lastCount = menuSurfaceElements().length;
        let stableRounds = 0;
        for (let settle = 0; rootMenuOpened && settle < 6; settle += 1) {
          await waitForDom(180);
          const count = menuSurfaceElements().length;
          captureSurface();
          stableRounds = count === lastCount ? stableRounds + 1 : 0;
          if (stableRounds >= 2) break;
          lastCount = count;
        }

        // Explore the model and effort submenus independently. Opening one portal
        // often detaches or hides the root menu, so close/reopen between passes
        // instead of keeping stale row references. No leaf is selected.
        const submenuRowFor = (kind) => menuSurfaceElements().find((el) => {
          const text = surfaceOptionText(el.textContent || el.getAttribute("aria-label") || "");
          const hasSubmenu = /^(?:menu|listbox)$/i.test(el.getAttribute("aria-haspopup") || "");
          if (ADAPTERS?.isCapabilitySubmenu) return ADAPTERS.isCapabilitySubmenu(kind, text, hasSubmenu);
          if (kind === "models") return /^(?:more|legacy|other|older)\s+models?\b|^expand\s+more\b/i.test(text);
          return /^(?:effort|thinking\s+(?:level|effort)|reasoning)\b/i.test(text);
        });

        const exploreSubmenu = async (kind) => {
          await closeCapabilitySurface(trigger);
          if (!await openTrigger()) return { opened: false, complete: false };
          const row = submenuRowFor(kind);
          if (!row) return { opened: false, complete: false };
          const before = (ADAPTERS ? ADAPTERS.unique(surfaceTexts()) : surfaceTexts()).sort().join("\n");
          hoverOpen(row);
          await waitForDom(180);
          let after = (ADAPTERS ? ADAPTERS.unique(surfaceTexts()) : surfaceTexts()).sort().join("\n");
          if (after === before && row.getAttribute("aria-expanded") !== "true") {
            row.click();
            await waitForDom(180);
            after = (ADAPTERS ? ADAPTERS.unique(surfaceTexts()) : surfaceTexts()).sort().join("\n");
          }
          captureSurface();
          const opened = row.getAttribute("aria-expanded") === "true" || after !== before;
          const complete = opened ? await captureMenuPages(captureSurface) : false;
          return { opened, complete };
        };

        // Peek at the still-open menu first: providers with flat menus (Gemini,
        // Grok, Perplexity, DeepSeek…) have no submenu rows, so both close/
        // reopen passes — the slowest part of the scan — are skipped entirely.
        rootMenuComplete = rootMenuOpened ? await captureMenuPages(captureSurface) : false;
        modelSubmenuRequired = rootMenuOpened && (!!submenuRowFor("models")
          || texts.some((text) => ADAPTERS?.isCapabilitySubmenu
            ? ADAPTERS.isCapabilitySubmenu("models", surfaceOptionText(text), false)
            : /^(?:more|legacy|other|older)\s+models?\b|^expand\s+more\b/i.test(surfaceOptionText(text))));
        effortSubmenuRequired = rootMenuOpened && (!!submenuRowFor("effort")
          || texts.some((text) => ADAPTERS?.isCapabilitySubmenu
            ? ADAPTERS.isCapabilitySubmenu("effort", surfaceOptionText(text), false)
            : /^(?:effort|thinking\s+(?:level|effort)|reasoning)\b/i.test(surfaceOptionText(text))));
        if (modelSubmenuRequired) {
          const result = await exploreSubmenu("models");
          modelSubmenuOpened = result.opened;
          modelSubmenuComplete = result.complete;
        }
        if (effortSubmenuRequired) {
          const result = await exploreSubmenu("effort");
          effortSubmenuOpened = result.opened;
          effortSubmenuComplete = result.complete;
        }

        await closeCapabilitySurface(trigger);
      }

      // Some providers expose the secondary axis in a wholly separate control:
      // Qwen has a Thinking combobox and Perplexity has a Search workflow menu.
      // Scan it independently instead of assuming every effort/mode is nested in
      // the model picker.
      if (secondaryControlSeparate) {
        secondaryMenuOpened = await openControl(secondaryTrigger);
        if (secondaryMenuOpened) {
          captureSurface();
          await waitForDom(180);
          captureSurface();
          secondaryMenuComplete = await captureMenuPages(captureSurface);
        }
        await closeCapabilitySurface(secondaryTrigger);
      }

      const modelDetails = ADAPTERS?.recognizeModelDetails
        ? ADAPTERS.recognizeModelDetails(config.name, texts)
        : [];
      const modelBadges = {};
      modelDetails.forEach((detail) => {
        if (detail.badges && detail.badges.length) modelBadges[detail.label] = detail.badges;
      });
      const models = ADAPTERS
        ? ADAPTERS.sanitizeModelLabels(config.name, ADAPTERS.unique([current?.label, ...modelDetails.map((detail) => detail.label), ...dynamicOptions]))
        : [current?.label].filter(Boolean);
      let efforts = ADAPTERS ? ADAPTERS.recognizeEfforts(config.name, texts) : [];
      // A few menus list only the non-default reasoning choice. Preserve the
      // configured default for the current model when any live effort evidence
      // was observed (Gemini lists "Extended thinking" but Standard is implicit).
      const currentModelConfig = (sharedConfig.models || []).find((model) => {
        const label = typeof model === "string" ? model : model?.label;
        return label === current?.label;
      });
      const defaultEffort = typeof currentModelConfig?.default === "string" ? currentModelConfig.default : "";
      if (efforts.length && defaultEffort) efforts = ADAPTERS.unique([defaultEffort, ...efforts]);
      const modes = ADAPTERS?.recognizeModes ? ADAPTERS.recognizeModes(config.name, texts) : [];
      const toggles = ADAPTERS ? ADAPTERS.recognizeToggles(config.name, texts) : [];
      const toggleStates = ADAPTERS?.recognizeToggleStates
        ? ADAPTERS.recognizeToggleStates(config.name, toggleEntries)
        : {};
      // Product surfaces (ChatGPT Chat/Work, Claude Chat/Cowork) are a
      // segmented radio pair captured by the same checked-state pass.
      const surfaceInfo = ADAPTERS?.recognizeSurfaces
        ? ADAPTERS.recognizeSurfaces(config.name, toggleEntries)
        : { surfaces: [], active: "" };
      // The currently selected operating mode, read from checked-state rows
      // rather than visible text ordering.
      const checkedTexts = toggleEntries.filter((entry) => entry.checked).map((entry) => entry.text);
      const activeModes = ADAPTERS?.recognizeModes ? ADAPTERS.recognizeModes(config.name, checkedTexts) : [];

      // Verification is category-specific. Finding an Extended toggle must not
      // certify a one-row model capture, and finding models must not make an empty
      // reasoning list authoritative.
      const selectorKind = sharedConfig.selectorKind || "model";
      const verification = ADAPTERS?.verificationForScan
        ? ADAPTERS.verificationForScan(sharedConfig, {
          nativeControl: nativePrimary,
          rootMenuOpened,
          rootMenuComplete,
          secondaryControlSeparate,
          secondaryNativeControl: !!secondaryTrigger,
          secondaryMenuOpened,
          secondaryMenuComplete,
          modelSubmenuRequired,
          modelSubmenuOpened,
          modelSubmenuComplete,
          effortSubmenuRequired,
          effortSubmenuOpened,
          effortSubmenuComplete,
          inlineModesObserved: inlineTexts.length > 0 && modes.length > 0,
          modesObserved: modes.length > 0,
          effortsObserved: efforts.length > 0,
          togglesObserved: toggles.length > 0 && (rootMenuOpened || inlineTexts.length > 0 || toggleEntries.length > 0),
          surfaces: surfaceInfo.surfaces
        })
        : {
          modelsVerified: false,
          modesVerified: false,
          effortsVerified: false,
          togglesVerified: false,
          surfacesVerified: false,
          primaryOptionsVerified: false,
          optionsVerified: false
        };
      const inferenceTexts = ADAPTERS ? ADAPTERS.unique(texts).slice(0, 80) : texts.slice(0, 80);
      const capabilities = {
        provider: config.name,
        schemaVersion: CAPABILITY_SCHEMA_VERSION,
        extensionVersion: EXTENSION_VERSION,
        routeFamily: routeFamily(),
        selectorKind,
        selectorLabel: sharedConfig.selectorLabel || "model",
        scanned: true,
        nativeControl: nativePrimary,
        ...verification,
        // Presence of the native control is what keeps the selector enabled;
        // an unverified option list only downgrades availability to
        // "uncertain" (see ShikiProviderAdapters.availabilityFor).
        modelSelector: nativePrimary,
        effortSelector: !!secondaryTrigger || !!inlinePrimaryControl()
          || efforts.length > 0 || toggles.length > 0 || modes.length > 0,
        models,
        modes,
        efforts,
        toggles,
        toggleStates,
        modelBadges,
        activeMode: activeModes[0] || "",
        surfaces: surfaceInfo.surfaces,
        activeSurface: surfaceInfo.active,
        voiceAvailable: !!findVoiceControl(),
        updatedAt: Date.now()
      };
      if (ADAPTERS) {
        // A model menu can advertise a higher paid tier (for example a Free
        // account seeing "ChatGPT Plus — Upgrade"). Direct account/profile plan
        // evidence is authoritative and must beat promotional menu copy.
        const accountPlan = ADAPTERS.inferPlan(config.name, { ...capabilities, texts: accountTexts });
        const inferredPlan = ADAPTERS.inferPlan(config.name, { ...capabilities, texts: inferenceTexts });
        capabilities.plan = accountPlan.confidence === "high" ? accountPlan : inferredPlan;
      } else {
        capabilities.plan = { label: "Unknown", confidence: "low", source: "capabilities" };
      }

      detectedCapabilities = capabilities;
      capabilityErrorRetries = 0;
      lastCapabilityScan = capabilities.updatedAt;
      cacheStats.lastScanDurationMs = Date.now() - scanStartedAt;
      capabilityStorage.get({ [CAPABILITIES_KEY]: {} }, (result) => {
        const all = result[CAPABILITIES_KEY] && typeof result[CAPABILITIES_KEY] === "object"
          ? { ...result[CAPABILITIES_KEY] }
          : {};
        all[config.name] = capabilities;
        capabilityStorage.set({ [CAPABILITIES_KEY]: all });
      });
      postState();
      return capabilities;
    })().catch(() => {
      const fallback = baseCapabilities();
      // A thrown probe did not verify absence. Keep the snapshot unscanned so
      // the skin uses catalog fallbacks, and retry a few times after transient
      // provider hydration/menu failures.
      fallback.scanned = false;
      fallback.plan = { label: "Unknown", confidence: "low", source: "scan-error" };
      detectedCapabilities = fallback;
      if (capabilityErrorRetries < 3) {
        capabilityErrorRetries += 1;
        window.setTimeout(() => discoverCapabilities(true), 700 * capabilityErrorRetries);
      }
      return fallback;
    }).finally(() => {
      revealNativeControls();
      capabilityScanPromise = null;
    });

    return capabilityScanPromise;
  }

  function stateFromPage() {
    const conversations = extractConversations();
    const activeConversation = extractActiveConversation(conversations);
    resetCachesForConversation(activeConversation);

    return {
      provider: provider().name,
      conversation: activeConversation,
      conversations,
      activeConversationId: activeConversation.id,
      model: extractModel(),
      effort: extractEffort(),
      capabilities: detectedCapabilities || baseCapabilities(),
      messages: extractMessages(),
      profileImage,
      richFormatting,
      imageControl,
      generating: detectGenerating(),
      historyLoading,
      historyHasMore,
      conversationsLoading,
      conversationsHasMore
    };
  }

  function sameArray(left, right, compare = (a, b) => a === b) {
    if (left === right) return true;
    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
    for (let index = 0; index < left.length; index += 1) {
      if (!compare(left[index], right[index])) return false;
    }
    return true;
  }

  function sameConversation(left, right) {
    return left === right || !!(left && right
      && left.id === right.id
      && left.href === right.href
      && left.title === right.title
      && left.label === right.label);
  }

  function sameMessage(left, right) {
    if (left === right) return true;
    if (!left || !right || left.author !== right.author || left.text !== right.text) return false;
    if (left.blocks !== right.blocks) return false;
    return sameArray(left.images || [], right.images || [], (a, b) => a === b || !!(a && b
      && a.src === b.src && a.alt === b.alt));
  }

  function sameState(left, right) {
    if (left === right) return true;
    if (!left || !right) return false;
    return left.provider === right.provider
      && sameConversation(left.conversation, right.conversation)
      && left.activeConversationId === right.activeConversationId
      && sameArray(left.conversations, right.conversations, sameConversation)
      && left.model?.id === right.model?.id
      && left.model?.label === right.model?.label
      && left.effort?.label === right.effort?.label
      && left.effort?.level === right.effort?.level
      && left.capabilities === right.capabilities
      && sameArray(left.messages, right.messages, sameMessage)
      && left.profileImage === right.profileImage
      && left.richFormatting === right.richFormatting
      && left.imageControl === right.imageControl
      && left.generating === right.generating
      && left.historyLoading === right.historyLoading
      && left.historyHasMore === right.historyHasMore
      && left.conversationsLoading === right.conversationsLoading
      && left.conversationsHasMore === right.conversationsHasMore;
  }

  // Avoid repeatedly structured-cloning and re-rendering an unchanged transcript.
  // The periodic heartbeat still scans the host page, but it only crosses the
  // iframe boundary when something visible or actionable actually changed.
  // Host apps that hydrate or reconcile at the document level (ChatGPT early,
  // Claude ~7s after load) sweep foreign <html> children, detaching the
  // workspace frame. Remount when that happens — rate-limited, and giving up
  // if a page removes it persistently so we never fight a remover forever.
  function remountFrameIfDetached() {
    if (!frame || frame.isConnected) return;
    if (!enabled || voicePassthrough || !isSupportedRoute()) return;
    const now = Date.now();
    if (now - lastFrameRemountAt <= 1200) return;
    if (now - frameRemountWindowStart > 60000) {
      frameRemountWindowStart = now;
      frameRemountCount = 0;
    }
    if (frameRemountCount >= 8) return;
    frameRemountCount += 1;
    lastFrameRemountAt = now;
    // Reattach directly (not ensureFrame) so a hidden workspace stays hidden:
    // remounting must restore presence, never override visibility choices.
    if (!document.getElementById(FRAME_ID)) {
      lastPostedState = null;
      document.documentElement.appendChild(frame);
    }
    if (!frame.hidden) document.documentElement.classList.add("shiki-docs-skin-active");
  }

  // The sweep can land while the tab is hidden (no heartbeat), so listen for
  // the removal itself instead of guessing times. The short delay lets a
  // wholesale reconciliation finish before we re-append.
  function watchFrameRemoval() {
    if (frameKeeperObserver) return;
    frameKeeperObserver = new MutationObserver(() => {
      if (!frame || frame.isConnected) return;
      window.setTimeout(remountFrameIfDetached, 150);
    });
    frameKeeperObserver.observe(document.documentElement, { childList: true });
  }

  function postState(force = false, preparedState = null) {
    // Watchdog: a detached frame has no contentWindow, so without this check
    // every later sync would silently no-op and the workspace never comes back.
    if (frame && !frame.isConnected) {
      remountFrameIfDetached();
      return preparedState;
    }
    if (!frame?.contentWindow) return preparedState;
    const state = preparedState || stateFromPage();
    if (!force && sameState(lastPostedState, state)) return state;
    lastPostedState = state;
    frame.contentWindow.postMessage({
      source: HOST_SOURCE,
      type: "host-state",
      state
    }, SKIN_ORIGIN);
    return state;
  }

  function notifySkin(type, payload = {}) {
    if (!frame?.contentWindow) return;
    frame.contentWindow.postMessage({ source: HOST_SOURCE, type, ...payload }, SKIN_ORIGIN);
  }

  function injectStyle() {
    // Build stamp so live pages reveal which extension build is running.
    try {
      document.documentElement.dataset.shikiBuild = chrome.runtime.getManifest().version_name
        || chrome.runtime.getManifest().version;
    } catch {
      /* orphaned context */
    }
    if (document.getElementById(STYLE_ID)) return;

    const style = document.createElement("style");
    style.id = STYLE_ID;
    style.textContent = `
      #${FRAME_ID} {
        position: fixed;
        inset: 0;
        width: 100vw;
        height: 100dvh;
        border: 0;
        z-index: 2147483647;
        background: #f8fafd;
      }

      html.shiki-docs-skin-active,
      html.shiki-docs-skin-active body {
        overflow: hidden !important;
      }

      html.${NATIVE_CONTROL_MASK_CLASS} [role="menu"],
      html.${NATIVE_CONTROL_MASK_CLASS} [role="listbox"],
      html.${NATIVE_CONTROL_MASK_CLASS} [role="dialog"],
      html.${NATIVE_CONTROL_MASK_CLASS} [popover]:popover-open,
      html.${NATIVE_CONTROL_MASK_CLASS} [data-radix-popper-content-wrapper],
      html.${NATIVE_CONTROL_MASK_CLASS} [data-base-ui-portal],
      html.${NATIVE_CONTROL_MASK_CLASS} [data-side][data-align],
      html.${NATIVE_CONTROL_MASK_CLASS} .ant-dropdown,
      html.${NATIVE_CONTROL_MASK_CLASS} .ant-select-dropdown,
      html.${NATIVE_CONTROL_MASK_CLASS} .n-popover__content.models-popover,
      html.${NATIVE_CONTROL_MASK_CLASS} .n-popover__content.effort-popover,
      html.${NATIVE_CONTROL_MASK_CLASS} .cdk-overlay-pane {
        opacity: 0 !important;
        pointer-events: none !important;
        transition: none !important;
        animation: none !important;
      }
    `;
    document.documentElement.appendChild(style);
  }

  function ensureFrame() {
    injectStyle();
    voicePassthrough = false;

    if (frame && !frame.isConnected) {
      // The host page removed the frame (document-level hydration). Reattach
      // the SAME node — it reloads index.html and the load listener re-posts
      // the full state. Guard against a duplicate mounted by a newer content
      // script generation after an extension reload.
      if (!document.getElementById(FRAME_ID)) {
        frame.hidden = false;
        frame.style.removeProperty("display");
        lastPostedState = null;
        document.documentElement.appendChild(frame);
      }
      document.documentElement.classList.add("shiki-docs-skin-active");
      return;
    }

    if (frame) {
      frame.hidden = false;
      frame.style.removeProperty("display");
      document.documentElement.classList.add("shiki-docs-skin-active");
      postState(true);
      return;
    }

    frame = document.createElement("iframe");
    frame.id = FRAME_ID;
    frame.title = "Docs style";
    frame.src = chrome.runtime.getURL("index.html");
    lastPostedState = null;
    frame.addEventListener("load", () => postState(true));
    document.documentElement.appendChild(frame);
    document.documentElement.classList.add("shiki-docs-skin-active");
    watchFrameRemoval();
  }

  function hideFrame() {
    if (frame) {
      frame.hidden = true;
      frame.style.setProperty("display", "none", "important");
    }
    document.documentElement.classList.remove("shiki-docs-skin-active");
  }

  function setEnabled(nextEnabled) {
    enabled = nextEnabled;
    voicePassthrough = false;
    chrome.storage.local.set({ [STORAGE_KEY]: enabled });

    if (enabled && isSupportedRoute()) {
      ensureFrame();
      startSync();
    } else {
      hideFrame();
      stopSync();
      nativeControlMaskDepth = 0;
      document.documentElement.classList.remove(NATIVE_CONTROL_MASK_CLASS);
    }
  }

  function toggle() {
    if (voicePassthrough) {
      ensureFrame();
      startSync();
      return;
    }
    setEnabled(!enabled);
  }

  function suspendForProviderVoice() {
    if (!frame) return;
    voicePassthrough = true;
    frame.hidden = true;
    document.documentElement.classList.remove("shiki-docs-skin-active");
    stopSync();
  }

  // Mutation-driven sync: the fixed-interval poll alone meant the document only
  // caught up to ~1.5s-old host state, so streaming replies looked choppy and
  // laggy. A MutationObserver on the host page pushes state the moment its DOM
  // changes, throttled so a burst of streaming mutations collapses into ~5 fast,
  // cheap syncs per second (skin.js no-ops when nothing actually changed). The
  // interval stays on as a heartbeat for state that doesn't mutate the DOM
  // (model/effort changes) and as a safety net if a mutation is ever missed.
  let observer = null;
  let observerSyncQueued = false;
  let lastObserverSync = 0;
  const OBSERVER_MIN_GAP_MS = 200;

  function isShikiOwnedNode(value) {
    const el = value?.nodeType === 1 ? value : value?.parentElement;
    if (!el) return false;
    if (el.id === FRAME_ID || el.id === STYLE_ID) return true;
    return !!el.closest?.(`#${FRAME_ID}, #${STYLE_ID}`);
  }

  function markDirtyMessagesInSubtree(value) {
    if (!value || value.nodeType !== 1) return false;
    const selectors = messageNodeSelectors();
    if (!selectors.length) return false;
    const selector = selectors.join(", ");
    let marked = false;
    try {
      if (value.matches(selector)) {
        dirtyMessageNodes.add(value);
        marked = true;
      }
      value.querySelectorAll(selector).forEach((node) => {
        dirtyMessageNodes.add(node);
        marked = true;
      });
    } catch {
      forceFullMessageScan = true;
      return true;
    }
    return marked;
  }

  function noteMutations(records) {
    let sawHostMutation = false;
    records.forEach((record) => {
      if (isShikiOwnedNode(record.target)) return;
      sawHostMutation = true;

      const targetMessage = closestMessageNode(record.target);
      if (targetMessage) dirtyMessageNodes.add(targetMessage);

      record.addedNodes.forEach((node) => {
        if (isShikiOwnedNode(node)) return;
        if (!markDirtyMessagesInSubtree(node)) {
          const message = closestMessageNode(node);
          if (message) dirtyMessageNodes.add(message);
        }
      });

      if (record.removedNodes.length) {
        forceFullMessageScan = true;
      }
    });
    return sawHostMutation;
  }

  function requestSync() {
    if (observerSyncQueued || !enabled) return;
    observerSyncQueued = true;
    const wait = Math.max(0, OBSERVER_MIN_GAP_MS - (Date.now() - lastObserverSync));
    window.setTimeout(() => {
      observerSyncQueued = false;
      lastObserverSync = Date.now();
      if (enabled) postState();
    }, wait);
  }

  function startObserver() {
    if (observer || !document.body) return;
    // Attributes are excluded on purpose: class/style churn is the noisiest
    // source of mutations and irrelevant here. Streaming text (characterData),
    // new turns, and the stop button toggling are all childList/characterData.
    observer = new MutationObserver((records) => {
      if (noteMutations(records)) requestSync();
    });
    observer.observe(document.body, { childList: true, subtree: true, characterData: true });
  }

  function stopObserver() {
    if (observer) {
      observer.disconnect();
      observer = null;
    }
  }

  function startSync() {
    stopSync();
    if (document.hidden) return;
    syncTimer = window.setInterval(postState, SYNC_INTERVAL_MS);
    startObserver();
  }

  function stopSync() {
    if (syncTimer) {
      window.clearInterval(syncTimer);
      syncTimer = 0;
    }
    stopObserver();
  }

  // Background provider tabs do not need to scrape and mirror their DOM until
  // the user returns. Resume with a forced state so the workspace catches up in
  // the same frame without losing any provider-side changes.
  document.addEventListener("visibilitychange", () => {
    if (!enabled || voicePassthrough) return;
    if (document.hidden) {
      stopSync();
    } else {
      startSync();
      postState(true);
    }
  });

  // The actual in-page sidebar anchor for a conversation, matched by href or by
  // pathname (our conversation id). Clicking it rides the host's own SPA router.
  function findConversationAnchor(conversationId, href) {
    const config = provider();
    const anchors = config.conversationSelectors.flatMap((selector) => Array.from(document.querySelectorAll(selector)));
    return anchors.find((anchor) => {
      const anchorHref = absoluteHref(anchor.getAttribute("href"));
      if (!anchorHref) return false;
      if (href && anchorHref === href) return true;
      try {
        return normalizeId(anchorHref, -1) === conversationId;
      } catch {
        return false;
      }
    });
  }

  // A plain, unmodified left click is what SPA routers (Next.js / React Router /
  // Angular) intercept for client-side navigation. Driving navigation this way
  // keeps the page — and therefore our overlay iframe — mounted, so switching
  // chats no longer triggers a full reload (which caused the flicker / the Docs
  // overlay vanishing for a split second).
  function spaClick(el) {
    const opts = { bubbles: true, cancelable: true, view: window, button: 0 };
    el.dispatchEvent(new MouseEvent("mousedown", opts));
    el.dispatchEvent(new MouseEvent("mouseup", opts));
    el.dispatchEvent(new MouseEvent("click", opts));
  }

  // After a client-side navigation the host swaps content asynchronously; push a
  // few syncs so the skin's transcript catches up without us reloading anything.
  function pushSyncs(extra = []) {
    const delays = [80, 200, 450, 900, 1500, 2500, 4000, ...extra];
    delays.forEach((delay) => window.setTimeout(postState, delay));
  }

  // The host keeps our overlay mounted but virtualizes chat turns — only the most
  // recent batch lives in the DOM until its scroll container is scrolled up. Walk
  // that container to force older messages to load before we scrape the thread.
  function threadScrollSelectors() {
    const host = location.hostname;
    if (host.includes("chatgpt") || host.includes("openai")) {
      return [
        "main [class*='overflow-y-auto']",
        "[data-testid='conversation-turns']",
        "main .flex.flex-col",
        "main"
      ];
    }
    if (host.includes("claude")) {
      return [
        "[data-testid='messages-container']",
        "[data-testid='conversation-container']",
        "main .overflow-y-auto",
        "main"
      ];
    }
    if (host.includes("gemini")) {
      return [
        "infinite-scroller",
        "message-list",
        "chat-window",
        "main"
      ];
    }
    if (host.includes("grok")) {
      return [
        '[data-testid*="conversation" i]',
        "main [class*='overflow-y-auto']",
        "main"
      ];
    }
    if (host.includes("deepseek")) {
      return [
        '[data-testid*="conversation" i]',
        "main [class*='overflow-y-auto']",
        "main [class*='scroll']",
        "main"
      ];
    }
    if (host.includes("copilot") || host.includes("perplexity") || host.includes("meta.ai")
      || host.includes("character") || host.includes("poe") || host === "pi.ai" || host === "hey.pi.ai"
      || host.includes("mistral") || host.includes("qwen") || host.includes("kimi")) {
      return [
        '[data-testid*="conversation" i]',
        '[data-testid*="messages" i]',
        'main [class*="overflow-y-auto"]',
        'main [class*="scroll"]',
        "main"
      ];
    }
    return ["main"];
  }

  function isScrollable(el) {
    if (!el || el.nodeType !== 1) return false;
    try {
      const style = getComputedStyle(el);
      if (!/(auto|scroll|overlay)/.test(style.overflowY)) return false;
      return el.scrollHeight > el.clientHeight + 8;
    } catch {
      return false;
    }
  }

  function fireScroll(el) {
    if (!el) return;
    try {
      el.dispatchEvent(new Event("scroll", { bubbles: true }));
    } catch {
      /* ignore */
    }
  }

  // Walk up from the first scraped turn to find the outermost scrollable ancestor.
  // This is more reliable than guessing selectors — especially while our overlay
  // has overflow:hidden on html/body.
  function scrollParentFromMessages() {
    const nodes = messageNodes();
    if (!nodes.length) return null;
    let el = nodes[0].parentElement;
    let outermost = null;
    while (el && el !== document.documentElement) {
      if (isScrollable(el)) outermost = el;
      el = el.parentElement;
    }
    return outermost;
  }

  function findThreadScroller() {
    const fromMessages = scrollParentFromMessages();
    if (fromMessages) return fromMessages;

    const nodes = messageNodes();
    if (nodes.length) {
      const scores = new Map();
      nodes.forEach((node) => {
        let el = node.parentElement;
        while (el && el !== document.body) {
          if (isScrollable(el)) scores.set(el, (scores.get(el) || 0) + 1);
          el = el.parentElement;
        }
      });
      let best = null;
      let bestScore = 0;
      scores.forEach((count, el) => {
        const score = count * 1000 + el.scrollHeight;
        if (score > bestScore) {
          bestScore = score;
          best = el;
        }
      });
      if (best) return best;
    }

    const seen = new Set();
    for (const selector of threadScrollSelectors()) {
      let elements = [];
      try {
        elements = Array.from(document.querySelectorAll(selector));
      } catch {
        elements = [];
      }
      for (const el of elements) {
        if (!el || seen.has(el)) continue;
        seen.add(el);
        if (isScrollable(el)) return el;
      }
    }

    return document.scrollingElement || document.documentElement;
  }

  function nudgeScrollerUp(scroller) {
    if (!scroller) return false;
    const before = scroller.scrollTop;
    const step = Math.max(120, Math.floor(scroller.clientHeight * 0.82));
    scroller.scrollBy(0, -step);
    fireScroll(scroller);
    if (scroller.scrollTop >= before - 2) {
      scroller.scrollTop = 0;
      fireScroll(scroller);
    }
    const nodes = messageNodes();
    if (nodes[0]) {
      try {
        nodes[0].scrollIntoView({ block: "start", inline: "nearest" });
        fireScroll(scroller);
      } catch {
        /* ignore */
      }
    }
    return scroller.scrollTop <= 2;
  }

  function firstMessageKey() {
    const nodes = messageNodes();
    if (!nodes.length) return "";
    return messageBodyText(nodes[0], detectAuthor(nodes[0], 0)).slice(0, 64);
  }

  function resetHistoryState() {
    historyHasMore = true;
    historyLoading = false;
  }

  // Pull one older batch from the host thread — only called when the user hits the
  // top of the Shiki doc and scrolls up for more (not on conversation open).
  function loadOlderBatch(done) {
    if (historyLoading) {
      done?.({ loaded: false });
      return;
    }
    if (!historyHasMore) {
      done?.({ loaded: false });
      return;
    }

    historyLoading = true;
    postState();

    const scroller = findThreadScroller();
    const beforeCount = messageNodes().length;
    const beforeHead = firstMessageKey();
    let settled = false;

    const finish = (loaded) => {
      if (settled) return;
      settled = true;
      historyLoading = false;
      if (!loaded) historyHasMore = false;
      postState();
      done?.({ loaded });
    };

    if (!scroller) {
      finish(false);
      return;
    }

    let nudges = 0;
    const maxNudges = 10;
    const pinTimer = window.setInterval(() => nudgeScrollerUp(scroller), 90);

    function check() {
      const afterCount = messageNodes().length;
      const afterHead = firstMessageKey();
      const loaded = afterCount > beforeCount || (!!afterHead && afterHead !== beforeHead);
      if (loaded || nudges >= maxNudges) {
        window.clearInterval(pinTimer);
        finish(loaded);
        return;
      }
      nudges += 1;
      nudgeScrollerUp(scroller);
      window.setTimeout(check, 320);
    }

    window.setTimeout(check, 380);
  }

  // Conversation anchors currently in the host sidebar DOM.
  function sidebarAnchors() {
    const config = provider();
    const anchors = config.conversationSelectors.flatMap((selector) => {
      try {
        return Array.from(document.querySelectorAll(selector));
      } catch {
        return [];
      }
    });
    return anchors.filter((anchor) => isConversationHref(anchor.getAttribute("href"), config));
  }

  // The host's own scrollable sidebar container (innermost scrollable ancestor of
  // the conversation links). Scrolling it down makes the host lazy-load more chats.
  function findSidebarScroller() {
    const anchors = sidebarAnchors();
    if (!anchors.length) return null;
    let el = anchors[0].parentElement;
    while (el && el !== document.documentElement) {
      if (isScrollable(el)) return el;
      el = el.parentElement;
    }
    return null;
  }

  // Pull the next batch of chats into the host sidebar — only called when the user
  // scrolls to the bottom of the Shiki conversation list and wants more.
  function loadMoreConversations(done) {
    if (conversationsLoading || !conversationsHasMore) {
      done?.({ loaded: false });
      return;
    }

    conversationsLoading = true;
    postState();

    const scroller = findSidebarScroller();
    const before = extractConversations().length;
    let settled = false;

    const finish = (loaded) => {
      if (settled) return;
      settled = true;
      conversationsLoading = false;
      if (!loaded) conversationsHasMore = false;
      postState();
      done?.({ loaded });
    };

    if (!scroller) {
      finish(false);
      return;
    }

    let nudges = 0;
    const maxNudges = 8;
    const nudge = () => {
      scroller.scrollTop = scroller.scrollHeight;
      fireScroll(scroller);
    };
    nudge();

    function check() {
      const after = extractConversations().length;
      if (after > before) {
        finish(true);
        return;
      }
      if (nudges >= maxNudges) {
        finish(false);
        return;
      }
      nudges += 1;
      nudge();
      window.setTimeout(check, 280);
    }

    window.setTimeout(check, 320);
  }

  function beginConversationLoad() {
    resetHistoryState();
    pushSyncs();
  }

  function switchConversation(conversationId) {
    resetHistoryState();
    const match = extractConversations().find((conversation) => conversation.id === conversationId);
    if (!match?.href) return;

    if (match.href === location.href) {
      beginConversationLoad();
      return;
    }

    const anchor = findConversationAnchor(conversationId, match.href);
    if (anchor) {
      spaClick(anchor);
      beginConversationLoad();
      // Safety net: if the SPA didn't honor the synthetic click, fall back to a
      // real navigation so clicking a chat never silently does nothing.
      window.setTimeout(() => {
        if (normalizeId(location.href, -1) !== conversationId && location.href !== match.href) {
          location.assign(match.href);
        }
      }, 900);
      return;
    }

    // No in-page link to ride the SPA router with → fall back to a hard
    // navigation (this still works, it just reloads the page).
    location.assign(match.href);
  }

  // Host-specific controls that start a fresh conversation. Clicking these keeps
  // us on the SPA (no reload); order is most-specific → most-generic.
  function newChatSelectors() {
    const host = location.hostname;
    if (host.includes("chatgpt") || host.includes("openai")) {
      return [
        'a[data-testid="create-new-chat-button"]',
        'button[data-testid="create-new-chat-button"]',
        'nav a[aria-label="New chat"]',
        'a[aria-label="New chat"]',
        'button[aria-label="New chat"]'
      ];
    }
    if (host.includes("claude")) {
      return [
        'a[href="/new"]',
        'a[aria-label*="new chat" i]',
        'button[aria-label*="new chat" i]',
        'button[aria-label*="start new" i]'
      ];
    }
    if (host.includes("gemini")) {
      return [
        '[data-test-id="new-chat-button"]',
        'button[aria-label*="new chat" i]',
        'a[aria-label*="new chat" i]',
        'button[aria-label*="new conversation" i]'
      ];
    }
    if (host.includes("grok")) {
      return [
        'a[href="/"][aria-label*="new" i]',
        'button[aria-label*="new chat" i]',
        'a[aria-label*="new chat" i]',
        'button[data-testid*="new-chat" i]'
      ];
    }
    if (host.includes("deepseek")) {
      return [
        'a[href="/"][aria-label*="new" i]',
        'button[aria-label*="new chat" i]',
        'a[aria-label*="new chat" i]',
        'button[data-testid*="new-chat" i]'
      ];
    }
    if (host.includes("copilot") || host.includes("perplexity") || host.includes("meta.ai")
      || host.includes("character") || host.includes("poe") || host === "pi.ai" || host === "hey.pi.ai"
      || host.includes("mistral") || host.includes("qwen") || host.includes("kimi")) {
      return [
        'a[aria-label*="new chat" i]',
        'button[aria-label*="new chat" i]',
        'a[aria-label*="new conversation" i]',
        'button[aria-label*="new conversation" i]',
        'button[data-testid*="new-chat" i]',
        'a[data-testid*="new-chat" i]'
      ];
    }
    return [];
  }

  function newChatUrl() {
    const host = location.hostname;
    if (host.includes("claude")) return "https://claude.ai/new";
    if (host.includes("gemini")) return "https://gemini.google.com/app";
    if (host.includes("grok")) return "https://grok.com/";
    if (host.includes("deepseek")) return "https://chat.deepseek.com/";
    if (host.includes("copilot")) return "https://copilot.microsoft.com/";
    if (host.includes("perplexity")) return "https://www.perplexity.ai/";
    if (host.includes("meta.ai")) return "https://www.meta.ai/";
    if (host.includes("character")) return "https://character.ai/";
    if (host.includes("poe")) return "https://poe.com/";
    if (host === "pi.ai" || host === "hey.pi.ai") return "https://pi.ai/talk";
    if (host.includes("mistral")) return "https://chat.mistral.ai/chat";
    if (host.includes("qwen")) return "https://chat.qwen.ai/";
    if (host.includes("kimi")) return "https://www.kimi.com/";
    return location.origin + "/";
  }

  function newChat() {
    resetHistoryState();
    const control = newChatSelectors().map(safeQuery).find(Boolean);
    if (control) {
      const before = location.href;
      spaClick(control);
      pushSyncs();
      // Safety net: if clicking the host's control didn't start a new chat,
      // navigate to the provider's new-chat URL instead.
      window.setTimeout(() => {
        if (location.href === before) location.assign(newChatUrl());
      }, 900);
      return;
    }
    // No recognizable new-chat control on the page → navigate to the provider's
    // new-chat URL as a fallback.
    location.assign(newChatUrl());
  }

  // Normalise a label/option to comparable text: lowercase, keep only letters,
  // digits and dots. This collapses hyphen/space/dash variants ("GPT-5.4",
  // "GPT 5.4", "GPT‑5.4" with a non-breaking hyphen) to one form while keeping the
  // dot so "5.4" and "5.5" stay distinct.
  function normOption(value) {
    return String(value || "").toLowerCase().replace(/[^a-z0-9.]/g, "");
  }

  function menuOptions() {
    return menuSurfaceElements();
  }

  // Hover-open a trigger/submenu WITHOUT clicking. Hosts disagree on what opens a
  // menu: ChatGPT's Radix menu opens on pointerdown, Claude's Base UI submenus open
  // on MOUSE hover (mouseover/enter/move), Gemini's Material button opens on click.
  // So fire both the mouse- and pointer-hover families here, but deliberately do
  // NOT click — a click after a pointerdown-open toggles Claude's menu back closed.
  // Callers fall back to .click() only when hovering didn't open the menu.
  function hoverOpen(el) {
    if (!el) return;
    ["mouseover", "mouseenter", "mousemove"].forEach((t) =>
      el.dispatchEvent(new MouseEvent(t, { bubbles: true, cancelable: true, view: window })));
    ["pointerover", "pointermove", "pointerenter", "pointerdown", "pointerup"].forEach((t) =>
      el.dispatchEvent(new PointerEvent(t, { bubbles: true, cancelable: true, pointerId: 1, pointerType: "mouse" })));
  }

  // Commit a selection on a leaf option: hover to focus it, then click to choose.
  function pressEl(el) {
    if (!el) return;
    hoverOpen(el);
    el.click();
  }

  // A menu row that opens a NESTED list of models rather than being a model itself.
  // Covers ChatGPT (the row is the *current* model name, e.g. "GPT-5.5 ❯", which
  // expands the full model list) and "More/Legacy/Other models" rows on other hosts.
  function modelSubmenuTrigger() {
    return menuOptions().find((el) =>
      el.getAttribute("aria-haspopup") === "menu"
      && /gpt[-\s]?\d|fable|opus|sonnet|haiku|gemini|grok|deepseek|sonar|qwen|kimi|muse\s+spark|vibe|chat styles?|pipsqueak|dynamic|\bo\d\b|more models|legacy models|other models|older models|bots?/i
        .test((el.textContent || "").trim()));
  }

  // Pick the option that best matches `labelText`. Prefer an exact label match,
  // then a row whose text STARTS WITH the label, then a loose substring — each pass
  // scans every option so a description line never beats the real model row, and
  // ties break to the shortest text so plain "GPT-5.5" wins over "GPT-5.5 Thinking".
  // Submenu triggers (aria-haspopup) are excluded so we never click the row that
  // merely *opens* the model list instead of a real model.
  function findMatchingOption(labelText, kind = "model") {
    let candidates = menuOptions()
      .filter((el) => el.getAttribute("aria-haspopup") !== "menu");
    if (location.hostname.includes("kimi")) {
      // Kimi's popup descendants have no option roles. Target only the native
      // clickable leaves: otherwise choosing an effort such as Max can match
      // the parent "Thinking effort · Max" row and merely reopen its submenu
      // while Shiki incorrectly reports a successful selection.
      const selector = kind === "effort"
        ? '.effort-popover .effort-option'
        : '.models-popover .model-item';
      candidates = Array.from(document.querySelectorAll(selector))
        .filter((el) => isElementVisible(el) && isMenuSurfaceElement(el));
      if (!candidates.length) return null;
    }
    const scored = candidates
      .map((el) => {
        const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.textContent || ""}`);
        const score = ADAPTERS?.modelOptionScore
          ? ADAPTERS.modelOptionScore(labelText, text)
          : (normOption(text).includes(normOption(labelText)) ? 1 : 0);
        return { el, score };
      })
      .filter((option) => option.score > 0)
      .sort((a, b) => b.score - a.score);
    return scored[0]?.el || null;
  }

  function clickMatchingOption(labelText, kind = "model") {
    const match = findMatchingOption(labelText, kind);
    if (!match) return false;
    pressEl(match);
    return true;
  }

  // A clicked row can silently not take (transitional portal state — observed
  // on Vibe) or be plan-gated into an upsell instead of switching (Grok and
  // Perplexity free tiers). Poll the host's own state after the click:
  // resolves true when confirmed applied, false when confirmed not applied;
  // a readMatch of null (provider exposes nothing to compare) counts as
  // applied so unverifiable hosts keep the old trust-the-click behavior.
  function verifySwitchApplied(readMatch, delays = [900, 1900]) {
    return new Promise((resolve) => {
      let last = null;
      const step = (index) => {
        if (index >= delays.length) {
          resolve(last !== false);
          return;
        }
        window.setTimeout(() => {
          last = readMatch();
          if (last === true) {
            resolve(true);
            return;
          }
          step(index + 1);
        }, index === 0 ? delays[0] : delays[index] - delays[index - 1]);
      };
      step(0);
    });
  }

  // Strip the effort words Gemini fuses into its pill ("Flash Extended") so a
  // combined label still verifies against the plain model row that was picked.
  function modelLabelForVerification(value) {
    return String(value || "").replace(/\s*\b(?:Extended|Thinking|Deep\s+Think)\b.*$/i, "").trim() || String(value || "");
  }

  function modelLabelsMatch(wanted, actual) {
    const cleanActual = modelLabelForVerification(actual);
    if (!cleanActual) return null;
    if (ADAPTERS?.modelOptionScore) {
      return ADAPTERS.modelOptionScore(wanted, cleanActual) > 0
        || ADAPTERS.modelOptionScore(cleanActual, wanted) > 0;
    }
    const a = normOption(wanted);
    const b = normOption(cleanActual);
    return a.includes(b) || b.includes(a);
  }

  function switchModel(label, retryBudget = 1) {
    if (!label) {
      postState();
      return;
    }
    // Open the host's model control, then click the matching option. The menu is a
    // portal that can render slowly and often nests the model list one level deep
    // (ChatGPT behind the current-model row, Claude behind "More models"), so we
    // poll rather than fire a single timed shot. Each tick does ONE thing: ensure
    // the menu is open, click the target if visible, or open a model submenu.
    // Self-closes (Escape) when nothing matches.
    // Resolve provider renames so a stale label from an old cache or the
    // static catalog still clicks the row the host actually shows today.
    const hostLabel = ADAPTERS?.resolveModelAlias
      ? ADAPTERS.resolveModelAlias(provider().name, label)
      : label;
    // Providers can leave hidden duplicate pickers mounted between responsive
    // layouts. Discovery already ignores those; selection must use the same rule
    // or it opens a detached trigger and never sees the live menu.
    const trigger = modelSelectors().map(safeQuery).find((el) => isElementVisible(el));
    if (!trigger) {
      notifySkin("selection-result", { control: "model", ok: false, reason: "selector-not-found", label });
      postState();
      return;
    }
    concealNativeControls();
    // Use the same real activation that capability discovery already proved for
    // this visible control. Synthetic hover/pointer events can leave the menu
    // closed while unrelated page switches make menuOptions() look non-empty.
    trigger.click();

    let tries = 0;
    let clickedTrigger = true;
    // Tracks submenu rows we've tried to open: "hovered" first, then a one-shot
    // click fallback for menus (ChatGPT) that don't open on hover.
    const subState = new Map();
    const attempt = () => {
      tries += 1;
      if (tries > 14) {
        settleNativeControlInteraction(trigger);
        // The advertised option was not in the live menu — the cached option
        // list is wrong, so force the next scan to re-read the page.
        lastCapabilityScan = 0;
        cacheStats.invalidations += 1;
        notifySkin("selection-result", { control: "model", ok: false, reason: "option-not-found", label });
        window.setTimeout(() => discoverCapabilities(true), 350);
        window.setTimeout(postState, 300);
        return;
      }
      // 1) Make sure the menu actually opened. Some triggers (Gemini's Material
      // button) need a real click; try that once, then fall back to re-hovering.
      if (!menuOptions().length) {
        if (!clickedTrigger) {
          clickedTrigger = true;
          trigger.click();
        } else {
          hoverOpen(trigger);
        }
        window.setTimeout(attempt, 180);
        return;
      }
      // 2) Click the target model as soon as it's visible, then verify the
      // host actually applied it before reporting success.
      if (clickMatchingOption(hostLabel)) {
        settleNativeControlInteraction(trigger);
        verifySwitchApplied(() => {
          const now = extractModel()?.label || "";
          if (!now) return null;
          return modelLabelsMatch(hostLabel, now);
        }).then((applied) => {
          if (applied) {
            notifySkin("selection-result", { control: "model", ok: true, label });
            window.setTimeout(() => discoverCapabilities(true), 250);
            window.setTimeout(postState, 150);
            return;
          }
          if (retryBudget > 0) {
            switchModel(label, retryBudget - 1);
            return;
          }
          lastCapabilityScan = 0;
          cacheStats.invalidations += 1;
          notifySkin("selection-result", { control: "model", ok: false, reason: "option-not-found", label });
          window.setTimeout(() => discoverCapabilities(true), 350);
          window.setTimeout(postState, 300);
        });
        return;
      }
      // 3) Target not visible yet — open the nested model submenu. Hover first;
      // if it didn't expand by the next pass, click it once.
      const sub = modelSubmenuTrigger();
      if (sub) {
        const state = subState.get(sub);
        if (!state) {
          hoverOpen(sub);
          subState.set(sub, "hovered");
        } else if (state === "hovered") {
          if (sub.getAttribute("aria-expanded") !== "true") sub.click();
          subState.set(sub, "clicked");
        }
      }
      window.setTimeout(attempt, 180);
    };
    window.setTimeout(attempt, 180);
  }

  function switchEffort(label, toggle, retryBudget = 1) {
    if (!label) {
      postState();
      return;
    }
    if (location.hostname.includes("deepseek")) {
      // DeepSeek's mode chips (Instant/Expert/Vision) and toggles (DeepThink/
      // Search) are inline styled spans, not menu options: click them by text.
      const wanted = normOption(label);
      const isToggleLabel = /deepthink|thinking|search/i.test(label);
      const target = Array.from(document.querySelectorAll('button, [role=button], [role=switch], span, div')).find((el) => {
        if (!isElementVisible(el) || el.children.length > 2) return false;
        const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.textContent || ""}`);
        if (!text || text.length > 24 || normOption(text) !== wanted) return false;
        return getComputedStyle(el).cursor === "pointer" || !!el.closest('[role="button"], button');
      });
      if (target && !isToggleLabel) {
        target.click();
        notifySkin("selection-result", { control: "effort", ok: true, label });
        window.setTimeout(() => discoverCapabilities(true), 450);
        window.setTimeout(postState, 250);
        return;
      }
      if (target && isToggleLabel) {
        const current = target.getAttribute("aria-checked") === "true"
          || target.getAttribute("aria-pressed") === "true"
          || target.classList.contains("active");
        const desired = toggle && typeof toggle === "object" ? !!toggle.on : !current;
        if (current !== desired) target.click();
        notifySkin("selection-result", { control: "effort", ok: true, label });
        window.setTimeout(() => discoverCapabilities(true), 450);
        window.setTimeout(postState, 250);
        return;
      }
    }
    // Effort lives in or beside the model picker on current provider UIs.
    // ChatGPT exposes levels directly; Claude/Gemini commonly put them
    // behind an Effort/Thinking level submenu. Poll both shapes and never click a
    // fuzzy "thinking" control unless the user picked that exact toggle.
    const trigger = effortSelectors().map(safeQuery).find((el) => isElementVisible(el));
    if (!trigger) {
      notifySkin("selection-result", { control: "effort", ok: false, reason: "selector-not-found", label });
      postState();
      return;
    }
    concealNativeControls();
    trigger.click();

    let tries = 0;
    let clickedTrigger = true;
    const submenuState = new Map();
    const desiredToggle = toggle && typeof toggle === "object" ? toggle : null;

    const findToggle = () => {
      const target = normOption(label);
      const candidates = Array.from(document.querySelectorAll('[role="switch"], button[aria-checked], button[aria-pressed]'));
      return candidates.find((el) => {
        const row = el.closest('[role="menuitem"], [role="option"], [role="menuitemradio"]') || el;
        return normOption(`${row.getAttribute("aria-label") || ""} ${row.textContent || ""}`).includes(target)
          && isElementVisible(el) && isMenuSurfaceElement(el);
      }) || null;
    };

    const attempt = () => {
      tries += 1;
      if (tries > 16) {
        settleNativeControlInteraction(trigger);
        lastCapabilityScan = 0;
        cacheStats.invalidations += 1;
        notifySkin("selection-result", { control: "effort", ok: false, reason: "option-not-found", label });
        window.setTimeout(() => discoverCapabilities(true), 350);
        window.setTimeout(postState, 250);
        return;
      }

      if (!menuSurfaceElements().length) {
        // Alternate activation styles: some pickers only open on a real click,
        // others (ChatGPT's Radix pill) only on pointer events.
        if (!clickedTrigger) trigger.click();
        else hoverOpen(trigger);
        clickedTrigger = !clickedTrigger;
        window.setTimeout(attempt, 160);
        return;
      }

      const toggleControl = desiredToggle ? findToggle() : null;
      if (toggleControl) {
        const current = toggleControl.getAttribute("aria-checked") === "true"
          || toggleControl.getAttribute("aria-pressed") === "true";
        if (current !== !!desiredToggle.on) toggleControl.click();
        settleNativeControlInteraction(trigger);
        notifySkin("selection-result", { control: "effort", ok: true, label });
        window.setTimeout(() => discoverCapabilities(true), 550);
        window.setTimeout(postState, 300);
        return;
      }

      // Gemini's "Standard" is not a row — it means re-picking the plain model.
      // The pill label fuses model+effort once Extended is active ("Flash
      // Extended"), so strip effort words or no menu row would ever match.
      const optionLabel = location.hostname.includes("gemini") && normOption(label) === "standard"
        ? (extractModel()?.label || label).replace(/\s*\b(?:Extended|Thinking|Deep\s+Think)\b.*$/i, "").trim() || label
        : label;
      if (!desiredToggle && clickMatchingOption(optionLabel, "effort")) {
        settleNativeControlInteraction(trigger);
        verifySwitchApplied(() => {
          const now = extractEffort();
          if (!now || !now.label) return null;
          return normOption(now.label) === normOption(label)
            // Gemini's Standard restore verifies as the effort chip vanishing
            // (extractEffort turns null) or reading the plain model again, so
            // only an explicit different effort counts as not-applied.
            || (normOption(label) === "standard" ? null : false);
        }).then((applied) => {
          if (applied) {
            notifySkin("selection-result", { control: "effort", ok: true, label });
            window.setTimeout(() => discoverCapabilities(true), 250);
            window.setTimeout(postState, 150);
            return;
          }
          if (retryBudget > 0) {
            switchEffort(label, toggle, retryBudget - 1);
            return;
          }
          lastCapabilityScan = 0;
          cacheStats.invalidations += 1;
          notifySkin("selection-result", { control: "effort", ok: false, reason: "option-not-found", label });
          window.setTimeout(() => discoverCapabilities(true), 350);
          window.setTimeout(postState, 300);
        });
        return;
      }

      const submenu = menuSurfaceElements().find((el) => {
        const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.textContent || ""}`);
        return /effort|thinking level|reasoning/i.test(text)
          && !/low|medium|high|standard|extended|deep think/i.test(text.replace(/thinking level/ig, ""));
      });
      if (submenu) {
        const state = submenuState.get(submenu);
        if (!state) {
          hoverOpen(submenu);
          submenuState.set(submenu, "hovered");
        } else if (state === "hovered" && submenu.getAttribute("aria-expanded") !== "true") {
          submenu.click();
          submenuState.set(submenu, "clicked");
        }
      }
      window.setTimeout(attempt, 170);
    };
    window.setTimeout(attempt, 220);
  }

  // Switch the host's product surface (ChatGPT Chat/Work, Claude Chat/Cowork):
  // click the segmented radio whose accessible text matches the requested
  // surface. Only checked-state radio/tab/pressed controls qualify, so sidebar
  // links to other products are never clicked.
  function switchSurface(label) {
    if (!label) return;
    const target = normOption(label);
    let control = null;
    if (location.hostname.includes("kimi")) {
      try {
        const candidates = Array.from(document.querySelectorAll('aside a, aside button, [role="navigation"] a, [role="navigation"] button'));
        control = candidates.find((el) => {
          if (!isElementVisible(el)) return false;
          const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.textContent || ""}`);
          if (target === "chat") return /new\s+chat/i.test(text) || /chat_enter_method=new_chat/i.test(el.getAttribute("href") || "");
          return normOption(text) === target || normOption(text) === `${target}beta`;
        }) || null;
      } catch {
        /* selector drift */
      }
      if (!control) {
        notifySkin("selection-result", { control: "surface", ok: false, reason: "selector-not-found", label });
        postState();
        return;
      }
      control.click();
      notifySkin("selection-result", { control: "surface", ok: true, label });
      lastCapabilityScan = 0;
      cacheStats.invalidations += 1;
      window.setTimeout(() => discoverCapabilities(true), 800);
      pushSyncs();
      return;
    }
    try {
      document.querySelectorAll('[role="radio"], [role="tab"], button[aria-pressed]').forEach((el) => {
        if (control || !isElementVisible(el)) return;
        const text = cleanText(`${el.getAttribute("aria-label") || ""} ${el.textContent || ""}`);
        if (!text || text.length > 40 || normOption(text) !== target) return;
        control = el;
      });
    } catch {
      /* selector drift */
    }
    if (!control) {
      notifySkin("selection-result", { control: "surface", ok: false, reason: "selector-not-found", label });
      postState();
      return;
    }
    const checked = control.getAttribute("aria-checked") === "true"
      || control.getAttribute("aria-pressed") === "true"
      || control.getAttribute("data-state") === "on"
      || control.getAttribute("aria-selected") === "true";
    if (!checked) control.click();
    notifySkin("selection-result", { control: "surface", ok: true, label });
    // A surface change swaps the whole product area: invalidate and rescan.
    lastCapabilityScan = 0;
    cacheStats.invalidations += 1;
    window.setTimeout(() => discoverCapabilities(true), 800);
    pushSyncs();
  }

  function startVoice() {
    const control = findVoiceControl();
    if (!control) {
      notifySkin("voice-result", { ok: false, reason: "voice-not-available" });
      discoverCapabilities(true);
      return;
    }
    control.click();
    notifySkin("voice-result", { ok: true });
    // Provider voice/live UIs render on the host page, underneath Shiki's
    // full-screen iframe. Temporarily reveal the host without changing the saved
    // enabled preference; the toolbar popup or keyboard shortcut restores Shiki.
    window.setTimeout(suspendForProviderVoice, 120);
  }

  window.addEventListener("message", (event) => {
    if (!frame || event.source !== frame.contentWindow) return;

    const message = event.data || {};
    if (message.source !== SKIN_SOURCE) return;

    if (message.type === "ready") {
      beginConversationLoad();
      window.setTimeout(() => discoverCapabilities(false), 200);
    }
    if (message.type === "switch-conversation") switchConversation(message.conversationId);
    if (message.type === "load-older-history") loadOlderBatch();
    if (message.type === "load-more-conversations") loadMoreConversations();
    if (message.type === "new-chat") newChat();
    if (message.type === "submit-prompt") {
      const reached = submitPrompt(message.text, message.images);
      if (!reached) notifySkin("submit-result", { ok: false, reason: "composer-not-found" });
      window.setTimeout(postState, 600);
    }
    if (message.type === "select-model") {
      switchModel(message.label || message.modelId);
    }
    if (message.type === "select-effort") {
      // Route the exact item the user picked (a reasoning level or the toggle) to
      // the host's reasoning control, best-effort.
      switchEffort(message.picked || message.label || message.effortLevel, message.toggle);
    }
    if (message.type === "select-surface") switchSurface(message.label);
    if (message.type === "discover-capabilities") discoverCapabilities(true);
    if (message.type === "start-voice") startVoice();
    if (message.type === "toggle-docs-style") {
      toggle();
    }
  });

  chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
    if (message?.type === "SHIKI_TOGGLE") {
      toggle();
      sendResponse({ enabled });
    }

    if (message?.type === "SHIKI_SET_ENABLED") {
      setEnabled(Boolean(message.enabled));
      sendResponse({ enabled });
    }

    if (message?.type === "SHIKI_GET_STATE") {
      sendResponse({ enabled, page: stateFromPage(), diagnostics: shikiDiagnostics() });
    }

    if (message?.type === "SHIKI_SYNC") {
      const page = stateFromPage();
      postState(true, page);
      sendResponse({ enabled, page, diagnostics: shikiDiagnostics() });
    }

    if (message?.type === "SHIKI_REFRESH_CAPABILITIES") {
      if (!isSupportedRoute()) {
        sendResponse({ enabled, capabilities: null, diagnostics: shikiDiagnostics() });
        return undefined;
      }
      discoverCapabilities(true).then((capabilities) =>
        sendResponse({ enabled, capabilities, page: stateFromPage(), diagnostics: shikiDiagnostics() }));
      return true;
    }
  });

  // Development/diagnostic detail for the popup: cache behavior, route support,
  // and scan timing. In-memory only.
  function shikiDiagnostics() {
    return {
      routeSupported: isSupportedRoute(),
      routeFamily: routeFamily(),
      capabilityAgeMs: lastCapabilityScan ? Date.now() - lastCapabilityScan : null,
      capabilityTtlMs: CAPABILITY_REFRESH_MS,
      cache: { ...cacheStats }
    };
  }

  // Re-evaluate SPA navigations: apply the route allowlist and invalidate the
  // capability cache when the app area (route family) changes.
  let lastWatchedHref = location.href;
  let lastWatchedFamily = routeFamily();
  window.setInterval(() => {
    if (location.href === lastWatchedHref) return;
    lastWatchedHref = location.href;
    const family = routeFamily();
    if (family !== lastWatchedFamily) {
      lastWatchedFamily = family;
      lastCapabilityScan = 0;
      earlyScanRetries = 0;
      routeHydrationStartedAt = Date.now();
      cacheStats.invalidations += 1;
    }
    const supported = isSupportedRoute();
    if (enabled && supported && !document.getElementById(FRAME_ID)) {
      ensureFrame();
      startSync();
      window.setTimeout(() => discoverCapabilities(false), 700);
    } else if (!supported && frame && !frame.hidden) {
      hideFrame();
      stopSync();
    }
  }, ROUTE_WATCH_MS);

  chrome.storage.local.get({ [STORAGE_KEY]: true, [PROFILE_KEY]: "", [RICH_KEY]: true, [IMAGE_CONTROL_KEY]: "composer" }, (result) => {
    enabled = Boolean(result[STORAGE_KEY]);
    profileImage = result[PROFILE_KEY] || "";
    richFormatting = result[RICH_KEY] !== false;
    imageControl = result[IMAGE_CONTROL_KEY] === "insert" || result[IMAGE_CONTROL_KEY] === "toolbar"
      ? "insert"
      : "composer";
    // Mount the workspace immediately after the single prefs read — the
    // capability cache is loaded in parallel below and only affects labels,
    // never whether the frame appears.
    if (enabled && isSupportedRoute()) {
      ensureFrame();
      startSync();
      // Document-level hydration (ChatGPT, Claude) can sweep the early frame.
      // The heartbeat only runs while the tab is visible, so background tabs
      // would otherwise stay swept until focus: a few one-shot checks let the
      // postState watchdog remount so the workspace is ready on switch-in.
      [900, 2500, 6000].forEach((delay) => window.setTimeout(() => {
        if (enabled) postState();
      }, delay));
    }
  });

  // Stale-while-revalidate: render immediately from the session-scoped cache,
  // then verify against the live page shortly after. Snapshots from another
  // schema, release, or app area are used for first paint but re-scanned.
  capabilityStorage.get({ [CAPABILITIES_KEY]: {} }, (cached) => {
    const providerName = provider().name;
    const saved = cached[CAPABILITIES_KEY] && cached[CAPABILITIES_KEY][providerName];
    const sanitized = ADAPTERS?.sanitizeCapabilitySnapshot
      ? ADAPTERS.sanitizeCapabilitySnapshot(providerName, saved, EXTENSION_VERSION)
      : null;
    if (sanitized) {
      detectedCapabilities = sanitized;
      lastCapabilityScan = sanitized.routeFamily === routeFamily()
        ? Number(sanitized.updatedAt) || 0
        : 0; // different app area — usable for paint, but revalidate now
      if (!lastCapabilityScan) cacheStats.invalidations += 1;
      postState();
    } else if (saved) {
      const all = { ...(cached[CAPABILITIES_KEY] || {}) };
      delete all[providerName];
      capabilityStorage.set({ [CAPABILITIES_KEY]: all });
    }
    if (isSupportedRoute()) {
      window.setTimeout(() => {
        if (enabled) discoverCapabilities(false);
      }, 350);
    }
  });

  // Reconcile enabled-state and profile picture across tabs and popup changes.
  chrome.storage.onChanged.addListener((changes, area) => {
    if (area !== "local") return;

    if (changes[STORAGE_KEY]) {
      const next = Boolean(changes[STORAGE_KEY].newValue);
      if (next !== enabled) setEnabled(next);
    }

    if (changes[PROFILE_KEY]) {
      profileImage = changes[PROFILE_KEY].newValue || "";
      postState();
    }

    if (changes[RICH_KEY]) {
      richFormatting = changes[RICH_KEY].newValue !== false;
      postState();
    }

    if (changes[IMAGE_CONTROL_KEY]) {
      imageControl = changes[IMAGE_CONTROL_KEY].newValue === "insert" || changes[IMAGE_CONTROL_KEY].newValue === "toolbar"
        ? "insert"
        : "composer";
      postState();
    }
  });
})();