bridge.js

/* WardenOne — Copyright (C) 2026 iri
   Licensed under the GNU General Public License v3 or later. See LICENSE.
   Official source: https://github.com/iri-dev/WardenOne
   Upstream filter-list attribution: CREDITS.md
   Redistributing a modified copy? GPLv3 section 5(a) requires you to mark it as changed,
   with the date, and to keep these notices intact. */
/*
 * WardenOne -- bridge (ISOLATED world)
 * ====================================
 * The MAIN-world content script (content.js) does the actual blocking, but it
 * can't talk to the extension's background service worker directly. This bridge
 * runs in the ISOLATED world (same page, but with access to chrome.* APIs) and
 * relays two things:
 *   1. block/detection events from the main world -> background (for the badge)
 *   2. config overrides from background -> main world (via window.postMessage)
 */
(function () {
  'use strict';

  const BRIDGE_VERSION = '1.0.2';
  if (window.__wardenOneBridgeVersion === BRIDGE_VERSION) {
    /* Same version: this document already has a current bridge. Let it re-run its replay,
       then stop -- unconditionally. The return used to sit INSIDE the typeof check, so a
       bridge whose replay had not been assigned yet (it is set 840 lines below this point, so
       anything throwing in between left the flag set and the replay missing), or whose replay
       a page had overwritten with a non-function, fell through and installed a SECOND complete
       bridge over the first: another 36 listeners, another observer, another runtime listener.
       A page could force that on demand with window.__wardenOneBridgeReplay = 1. */
    try {
      if (typeof window.__wardenOneBridgeReplay === 'function') window.__wardenOneBridgeReplay();
    } catch (_) {}
    return;
  }
  if (window.__wardenOneBridgeVersion) {
    /* A different version means this document holds an older bridge -- after an extension
       update, or after Repair marked it stale so it could re-arm the tab. Release what that
       copy holds before installing over it, or both stay live and both are charged for every
       event the page produces. */
    try {
      if (typeof window.__wardenOneBridgeDispose === 'function') window.__wardenOneBridgeDispose();
    } catch (_) {}
  }
  window.__wardenOneBridgeVersion = BRIDGE_VERSION;

  /* Everything this copy holds, so the next one can let it go. Listeners ride a single abort
     signal; observers and intervals are collected; timeouts remove their own id when they fire,
     so a self-rescheduling loop cannot grow this set without bound. */
  const woAbort = new AbortController();
  const woKeep = [];
  const woPending = new Set();
  const woHold = (item) => { woKeep.push(item); return item; };
  const woOn = (target, type, fn, opts) => {
    const base = (opts && typeof opts === 'object')
      ? Object.assign({}, opts)
      : (opts === true ? { capture: true } : {});
    base.signal = woAbort.signal;
    try { target.addEventListener(type, fn, base); } catch (_) {}
  };
  const woObserver = (...a) => woHold(new MutationObserver(...a));
  const woInterval = (...a) => woHold(setInterval(...a));
  /* A normal function, not an arrow: three call sites pass function-keyword callbacks, and
     forwarding `this` keeps them behaving exactly as the host would call them. */
  const woTimeout = (fn, ms, ...rest) => {
    let id;
    id = setTimeout(function (...a) {
      woPending.delete(id);
      return typeof fn === 'function' ? fn.apply(this, a) : undefined;
    }, ms, ...rest);
    woPending.add(id);
    return id;
  };
  // Chrome's extension events are not DOM events: they are not covered by the abort signal above
  // and they have no equivalent of removeEventListener-by-signal. Repair reinstalls bridge.js in
  // every frame, so a listener registered here and never removed accumulates one more copy per
  // Repair -- and every copy answers, so old and new bridges race on form and media health.
  //
  // The exact callback reference has to be kept, because removeListener matches by identity.
  const woChromeListeners = [];
  const woOnMessage = (fn) => {
    try {
      chrome.runtime.onMessage.addListener(fn);
      woChromeListeners.push([chrome.runtime.onMessage, fn]);
    } catch (_) {}
    return fn;
  };

  /* Overlays this copy currently has on screen. Bridge-only, like the Chrome listeners above, so
     it lives outside the registry core the other nine guards share.
     destroy() is the only thing that releases the keyboard trap, hands focus back, stops the
     self-healing watcher and removes the host -- and dispose has to be able to reach them. Every
     button inside a warning is registered through woOn, so it rides the abort signal; the trap is
     a raw listener on the host and does not. A bridge replaced while a warning is up therefore
     used to abort every button and leave the dialog on the page with nothing able to close it.
     That is not a rare path: Repair deliberately stamps this file's version flag stale and
     re-injects (background.js REPAIR_COMPONENTS), and people press Repair precisely when something
     looks wrong -- which is when a warning is most likely to be showing. */
  const woOverlays = new Set();

  window.__wardenOneBridgeDispose = () => {
    /* Before anything is torn down, while focus restoration can still land somewhere real.
       Each destroy() deregisters itself, so the set is drained rather than iterated in place. */
    const overlays = Array.from(woOverlays);
    woOverlays.clear();
    for (const overlay of overlays) {
      try { overlay.destroy(); } catch (_) {}
    }
    try { woAbort.abort(); } catch (_) {}
    woPending.forEach((id) => { try { clearTimeout(id); } catch (_) {} });
    woPending.clear();
    const held = woKeep.splice(0, woKeep.length);
    for (const item of held) {
      try {
        if (item && typeof item.disconnect === 'function') item.disconnect();
        else clearInterval(item);
      } catch (_) {}
    }
    const chromeHeld = woChromeListeners.splice(0, woChromeListeners.length);
    for (const [event, fn] of chromeHeld) {
      try { event.removeListener(fn); } catch (_) {}
    }
  };

  // A per-page-load routing token. It keeps accidental/cross-extension messages
  // out, but the MAIN-world page can observe window messages, so background-side
  // handlers still treat token-bearing page events as forgeable and constrain the
  // dangerous paths with sender checks, rate limits, and sanitized inputs.
  // A ROUTING NONCE, not a secret (M27).
  //
  // This value is broadcast into the page with postMessage so the MAIN-world scripts can tag their
  // traffic back. The page shares that world, so any script listening early enough holds it as
  // well. It exists to tell WardenOne's messages apart from every other postMessage on a busy
  // page, and to stop stale traffic from a previous bridge being answered -- nothing more.
  //
  // Checking `d.token === TOKEN` therefore proves the message is addressed to this bridge. It does
  // NOT prove who sent it. Anything arriving over a page-visible channel must be treated as a
  // claim, and must not be sufficient on its own to change trusted state: the permission-chain
  // path now requires corroboration the worker gathered itself before it will warn or write
  // history. Add a new inbound signal here and the same rule applies to it.
  const TOKEN = (function () {
    try {
      const a = new Uint32Array(4); crypto.getRandomValues(a);
      return Array.from(a, (n) => n.toString(36)).join('');
    } catch (_) { return String(Math.random()) + Date.now().toString(36); }
  })();

  // The postMessage nonce is public. MAIN-world authority instead uses a key
  // handed off synchronously at document_start and never replayed. Signed
  // sequence payloads prevent forgery; late engine injection reloads the tab
  // because no private MAIN-world hand-off remains after page scripts run.
  /* HMAC-SHA256 over UTF-8 text, in plain JS. crypto.subtle is absent on http: pages and
     asynchronous everywhere, and this has to answer inside a synchronous DOM event. Every
     reference it needs is captured here, before the page runs, so a page that rewrites
     TextEncoder or Uint8Array later changes nothing about what it computes. Not a general
     library: fixed 32-byte key (hex), text in, hex out. */
  const __woAuth=(function(){
    const K=[0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2];
    const U8=Uint8Array,U32=Uint32Array,D="0123456789abcdef";
    /* This code runs in the page's own world, where the page can replace any built-in method after
       load. So nothing that touches the key calls one. The key becomes its two HMAC pad blocks ONCE,
       in key(), at the document_start hand-off before any page script exists; after that a
       signature is index reads and arithmetic on typed arrays -- no .set, .subarray, .length,
       substr, parseInt or toString -- each of which a page could replace to be handed the key: a
       patched String.prototype.substr, Uint8Array.prototype.set or typed-array length getter each
       recovered the whole key from one signature (tools/test-main-world-key-isolation.js). The
       message text is not secret; a page that tampers with how it is read only spoils its own
       signature, which it could already do by stopping the event. */
    function encode(text){
      const s=String(text),out=new U8(3*s.length+3);
      let n=0;
      for(let i=0;i<s.length;i++){
        let c=s.charCodeAt(i);
        if(c>=0xd800&&c<0xdc00&&i+1<s.length){const d=s.charCodeAt(i+1);if(d>=0xdc00&&d<0xe000){c=0x10000+((c-0xd800)<<10)+(d-0xdc00),i++}}
        if(c<0x80)out[n++]=c;
        else if(c<0x800)out[n++]=0xc0|(c>>6),out[n++]=0x80|(c&63);
        else if(c<0x10000)out[n++]=0xe0|(c>>12),out[n++]=0x80|((c>>6)&63),out[n++]=0x80|(c&63);
        else out[n++]=0xf0|(c>>18),out[n++]=0x80|((c>>12)&63),out[n++]=0x80|((c>>6)&63),out[n++]=0x80|(c&63)
      }
      return{b:out,n:n}
    }
    const rotr=(x,n)=>(x>>>n)|(x<<(32-n));
    function sha256(msg,len){
      const total=((len+9+63)>>6)<<6,padded=new U8(total);
      for(let i=0;i<len;i++)padded[i]=msg[i];
      padded[len]=0x80;
      const bits=len*8;
      padded[total-4]=(bits>>>24)&255,padded[total-3]=(bits>>>16)&255,padded[total-2]=(bits>>>8)&255,padded[total-1]=bits&255;
      const h=new U32(8),w=new U32(64);
      h[0]=0x6a09e667,h[1]=0xbb67ae85,h[2]=0x3c6ef372,h[3]=0xa54ff53a,h[4]=0x510e527f,h[5]=0x9b05688c,h[6]=0x1f83d9ab,h[7]=0x5be0cd19;
      for(let off=0;off<total;off+=64){
        for(let i=0;i<16;i++)w[i]=(padded[off+4*i]<<24)|(padded[off+4*i+1]<<16)|(padded[off+4*i+2]<<8)|padded[off+4*i+3];
        for(let i=16;i<64;i++){
          const s0=rotr(w[i-15],7)^rotr(w[i-15],18)^(w[i-15]>>>3),s1=rotr(w[i-2],17)^rotr(w[i-2],19)^(w[i-2]>>>10);
          w[i]=(w[i-16]+s0+w[i-7]+s1)|0
        }
        let a=h[0],b=h[1],c=h[2],d=h[3],e=h[4],f=h[5],g=h[6],k=h[7];
        for(let i=0;i<64;i++){
          const S1=rotr(e,6)^rotr(e,11)^rotr(e,25),ch=(e&f)^(~e&g),t1=(k+S1+ch+K[i]+w[i])|0,S0=rotr(a,2)^rotr(a,13)^rotr(a,22),mj=(a&b)^(a&c)^(b&c),t2=(S0+mj)|0;
          k=g,g=f,f=e,e=(d+t1)|0,d=c,c=b,b=a,a=(t1+t2)|0
        }
        h[0]=(h[0]+a)|0,h[1]=(h[1]+b)|0,h[2]=(h[2]+c)|0,h[3]=(h[3]+d)|0,h[4]=(h[4]+e)|0,h[5]=(h[5]+f)|0,h[6]=(h[6]+g)|0,h[7]=(h[7]+k)|0
      }
      const out=new U8(32);
      for(let i=0;i<8;i++)out[4*i]=h[i]>>>24,out[4*i+1]=(h[i]>>>16)&255,out[4*i+2]=(h[i]>>>8)&255,out[4*i+3]=h[i]&255;
      return out
    }
    function hex(bytes){
      let s="";
      for(let i=0;i<32;i++)s+=D[bytes[i]>>4]+D[bytes[i]&15];
      return s
    }
    /* The key's two pad blocks, made once. Call it only where the page cannot have run yet (the
       wo-key hand-off at document_start) or cannot reach (the bridge's own world). */
    function key(keyHex){
      const s=String(keyHex||""),n=s.length>>1,raw=new U8(n);
      for(let i=0;i<n;i++)raw[i]=parseInt(s.substr(2*i,2),16)||0;
      const k=n>64?sha256(raw,n):raw,kl=n>64?32:n,ipad=new U8(64),opad=new U8(64);
      for(let i=0;i<64;i++){
        const b=i<kl?k[i]:0;
        ipad[i]=b^0x36,opad[i]=b^0x5c
      }
      return{i:ipad,o:opad}
    }
    function hmac(k,text){
      const pads="string"==typeof k?key(k):k,e=encode(text),n=e.n,data=e.b,inner=new U8(64+n),outer=new U8(96);
      for(let i=0;i<64;i++)inner[i]=pads.i[i],outer[i]=pads.o[i];
      for(let i=0;i<n;i++)inner[64+i]=data[i];
      const ih=sha256(inner,64+n);
      for(let i=0;i<32;i++)outer[64+i]=ih[i];
      return hex(sha256(outer,96))
    }
    /* Constant-time-enough equality for two short hex strings; a mismatch is not a secret. */
    function same(a,b){
      a=String(a||""),b=String(b||"");
      if(a.length!==b.length||!a.length)return!1;
      let diff=0;
      for(let i=0;i<a.length;i++)diff|=a.charCodeAt(i)^b.charCodeAt(i);
      return 0===diff
    }
    /* A signed event's text: who sent it, its number, its type and a canonical form of its detail
       -- keys sorted, every value typed, every string length-prefixed -- so the page's world and
       the bridge's, which each hold their own copy of the detail, compute the same text from it. */
    function canon(v,depth){
      if(void 0===v)return"u";
      if(null===v)return"n";
      const t=typeof v;
      if("string"===t)return"s"+v.length+":"+v;
      if("number"===t)return"d"+String(v);
      if("boolean"===t)return v?"T":"F";
      if("object"!==t||depth>8)return"x";
      let s;
      if(Array.isArray(v)){
        s="[";
        for(let i=0;i<v.length&&i<256;i++)s+=canon(v[i],depth+1)+",";
        return s+"]"
      }
      const keys=Object.keys(v).sort();
      s="{";
      for(let i=0;i<keys.length&&i<256;i++)s+=keys[i].length+":"+keys[i]+"="+canon(v[keys[i]],depth+1)+",";
      return s+"}"
    }
    function eventText(src,seq,type,detail){
      return"event\n"+String(src)+"\n"+String(seq)+"\n"+String(type)+"\n"+canon(detail,0)
    }
    return{hmac:hmac,same:same,key:key,canon:canon,eventText:eventText}
  })();

  const KEY = (function () {
    try {
      const b = new Uint8Array(32); crypto.getRandomValues(b);
      let out = '';
      for (let i = 0; i < b.length; i++) out += (b[i] < 16 ? '0' : '') + b[i].toString(16);
      return out;
    } catch (_) { return ''; }
  })();
  // "The page could have run": a script of the page's own exists only once the parser has
  // produced a <script>, a frame or plugin element, an element carrying an on* handler
  // attribute, or the <body> -- or once the document has finished loading. At document_start
  // none of that has been built. What may already sit under <html> is a <style> or two that
  // this extension's own MAIN-world modules (Spotify, Twitch, YouTube) append before this
  // bridge runs; those are inert. The first seal counted any element at all as "the page has
  // run", so on exactly those sites the key never went out and every signed message that
  // followed was refused.
  const BRIDGE_INERT_TAG = /^(?:head|meta|title|link|style|base)$/;
  const pageCouldHaveRun = () => {
    try {
      if (document.readyState !== 'loading' || document.body) return true;
      const root = document.documentElement;
      if (!root) return false;
      const all = root.getElementsByTagName('*');
      if (all.length > 64) return true;
      for (let i = -1; i < all.length; i++) {
        const el = i < 0 ? root : all[i];
        if (i >= 0 && !BRIDGE_INERT_TAG.test(String(el.localName || '').toLowerCase())) return true;
        const attrs = el.attributes;
        for (let j = 0; attrs && j < attrs.length; j++) {
          if (/^on/i.test(String(attrs[j].name || ''))) return true;
        }
      }
      return false;
    } catch (_) { return true; }
  };
  const BRIDGE_FRESH = !pageCouldHaveRun();
  const deliverKey = () => {
    if (!KEY || pageCouldHaveRun()) return false;
    try {
      document.dispatchEvent(new CustomEvent('wo-key', { detail: { token: TOKEN, key: KEY } }));
      return true;
    } catch (_) { return false; }
  };
  let authSeq = 0;
  // Sign a message in place: one counter for every kind, so a replayed message -- even a
  // genuine one from a minute ago -- fails on its sequence number.
  const signed = (kind, payload, message) => {
    authSeq += 1;
    message.seq = authSeq;
    message.mac = KEY ? __woAuth.hmac(KEY, authSeq + '\n' + kind + '\n' + String(payload)) : '';
    return message;
  };
  const engineMac = (kind, text) => (KEY ? __woAuth.hmac(KEY, kind + '\n' + String(text)) : '');

  /* ROUTING TOKEN = ROUTING ONLY; THE KEY = ANYTHING WARDENONE BELIEVES.
     The token rides every message on this bus and a page can read it, so a message that carries
     only the token proves nothing about who sent it. Security events (blocked_*, detected_*,
     gated_*, warned_*, behavioral_risk) were accepted on the token alone: a page could dispatch
     blocked_payment_card_submit or detected_grabber_domain about itself and have WardenOne put it
     in the Activity log, count it on the toolbar badge and pop its own branded notice on the page.
     The permission-chain signal, the media-active flag Memory Shield consults before sleeping a
     tab, and the reload-loop notice worked the same way. Each is now signed under the key this
     bridge handed out at document_start, over a number that only moves forward -- one counter per
     sender -- and its content; a page can still dispatch all of them, and none of them counts. */
  const KEY_PADS = KEY ? __woAuth.key(KEY) : null;
  const EVENT_SOURCES = new Set(['engine', 'hardener', 'miner', 'bridge', 'adshield']);
  const eventSeqSeen = Object.create(null);
  const eventSigned = (d) => {
    const src = String((d && d.src) || '');
    const seq = Number(d && d.eseq);
    if (!KEY_PADS || !EVENT_SOURCES.has(src) || !Number.isInteger(seq) || seq <= (eventSeqSeen[src] || 0)) return false;
    if (!__woAuth.same(d.emac, __woAuth.hmac(KEY_PADS, __woAuth.eventText(src, seq, String(d.type || ''), d.detail)))) return false;
    eventSeqSeen[src] = seq;
    return true;
  };
  let bridgeEventSeq = 0;
  /* The bridge's own notices -- the answer to a right-click check the reader asked for -- go out
     signed as the 'bridge' sender, so the engine's notice card believes them like any other. It is
     reachable only from this extension's own world (the worker runs a one-line script there); the
     page cannot see or call it. */
  const dispatchLocalNotice = (type, detail) => {
    if (!KEY_PADS || !/^detected_manual_check$/.test(String(type || ''))) return false;
    bridgeEventSeq += 1;
    const safe = boundedBridgeDetail(detail || {});
    try {
      document.dispatchEvent(new CustomEvent('wo-event', { detail: {
        token: TOKEN, type, detail: safe, src: 'bridge', eseq: bridgeEventSeq,
        emac: __woAuth.hmac(KEY_PADS, __woAuth.eventText('bridge', bridgeEventSeq, type, safe)),
      } }));
      return true;
    } catch (_) { return false; }
  };
  const dispatchWarningDecision = (id, decisionId) => {
    if (!KEY_PADS || id !== 'wo-paste-warn' || !Number.isSafeInteger(decisionId) || decisionId < 1) return false;
    bridgeEventSeq += 1;
    const type = 'warning_decision';
    const detail = { id, decisionId };
    try {
      document.dispatchEvent(new CustomEvent('wo-event', { detail: {
        token: TOKEN, type, detail, src: 'bridge', eseq: bridgeEventSeq,
        emac: __woAuth.hmac(KEY_PADS, __woAuth.eventText('bridge', bridgeEventSeq, type, detail)),
      } }));
      return true;
    } catch (_) { return false; }
  };
  try { Object.defineProperty(window, '__wardenOneLocalNotice', { value: dispatchLocalNotice, configurable: true }); } catch (_) {}
  let permSignalSeqSeen = 0;
  const permissionSignalSigned = (d) => {
    const seq = Number(d && d.pseq);
    if (!KEY_PADS || !Number.isInteger(seq) || seq <= permSignalSeqSeen) return false;
    const body = Object.assign({}, d);
    delete body.token; delete body.pseq; delete body.pmac;
    if (!__woAuth.same(d.pmac, __woAuth.hmac(KEY_PADS, 'permission\n' + seq + '\n' + __woAuth.canon(body, 0)))) return false;
    permSignalSeqSeen = seq;
    return true;
  };
  let pageNoticeSeqSeen = 0;
  const pageNoticeSigned = (kind, data, extra) => {
    const seq = Number(data && data.seq);
    if (!KEY_PADS || !Number.isInteger(seq) || seq <= pageNoticeSeqSeen) return false;
    if (!__woAuth.same(data.mac, __woAuth.hmac(KEY_PADS, kind + '\n' + seq + '\n' + String(extra || '')))) return false;
    pageNoticeSeqSeen = seq;
    return true;
  };
  const BRIDGE_RATE = Object.create(null);
  function bridgeRateOk(bucket, max, windowMs) {
    const key = String(bucket || 'message');
    const now = Date.now();
    const start = now - (Number(windowMs) || 60000);
    const hits = Array.isArray(BRIDGE_RATE[key]) ? BRIDGE_RATE[key].filter((t) => t > start) : [];
    if (hits.length >= (Number(max) || 60)) {
      BRIDGE_RATE[key] = hits;
      return false;
    }
    hits.push(now);
    BRIDGE_RATE[key] = hits;
    return true;
  }

  /* User-picked hidden elements are not AdShield rules. Load them directly from
     this isolated bridge so they still apply when AdShield is off or the site is
     allowlisted. Keeping this request here also avoids exposing hidden-add/remove
     through the forgeable MAIN-world relay below. */
  function bridgeSafeUserSelector(value) {
    const selector = String(value || '').trim();
    if (!selector || selector.length > 400 || /[{}<;@\\]/.test(selector)) return '';
    if (selector.indexOf('/*') >= 0 || selector.indexOf('*/') >= 0) return '';
    for (let i = 0; i < selector.length; i++) if (selector.charCodeAt(i) < 0x20) return '';
    if (/^(html|body|:root|\*)$/i.test(selector)) return '';
    return selector;
  }
  function bridgeApplyUserHidden(list) {
    try {
      const selectors = (Array.isArray(list) ? list : [])
        .map(bridgeSafeUserSelector).filter(Boolean).slice(0, 100);
      let style = document.querySelector('style[data-wardenone-user-hidden="true"]');
      if (!style) {
        style = document.createElement('style');
        style.id = 'wo-user-hidden';
        style.setAttribute('data-wardenone-user-hidden', 'true');
        (document.head || document.documentElement).appendChild(style);
      }
      style.textContent = selectors.map((selector) => selector + '{display:none!important;}').join('');

      /* The in-page Zapper marks what it hid with an attribute as well as
         relying on this stylesheet, and that attribute outlives the rule being
         deleted -- so dropping a selector left the element gone until the page
         was reloaded. That is exactly why undo in the popup used to reload the
         tab after EVERY item, which on a site with a few saved rules looked
         like a reload loop and tripped WardenOne's own detector. Clearing the
         mark here makes undo take effect in place, so nothing has to reload. */
      try {
        const marked = document.querySelectorAll('[data-wardenone-zapped="true"]');
        for (let i = 0; i < marked.length; i++) {
          const node = marked[i];
          let stillHidden = false;
          for (let j = 0; j < selectors.length; j++) {
            try { if (node.matches(selectors[j])) { stillHidden = true; break; } } catch (_) {}
          }
          if (!stillHidden) node.removeAttribute('data-wardenone-zapped');
        }
      } catch (_) {}
    } catch (_) {}
  }
  /* The initial rules arrive with the config (content-config-get answers with a hidden list), so
     this separate round trip is only for a refresh after the reader edits the list. Every
     frame used to make it at document_start as well -- one of the two channels each child
     frame opened before doing anything, which PERF-02's fixture put at about a millisecond
     per frame. */
  function bridgeLoadUserHidden() {
    try {
      if (!/^https?:$/.test(location.protocol) || !location.hostname) return;
      chrome.runtime.sendMessage({ kind: 'hidden-list', hostname: location.hostname }, (res) => {
        void chrome.runtime.lastError;
        if (!res || !res.ok) return;
        bridgeApplyUserHidden(res.inherited);
      });
    } catch (_) {}
  }
  /* Tell the worker a menu is about to open, so "Block this site" can name the
     site instead of guessing. Chrome fires no event when a context menu opens,
     and refreshing on tab switches alone left the entry reading "(not a normal
     page)" on ordinary pages. A right-click is rare and this listener does
     nothing else, so it costs nothing between clicks. */
  woOn(window, 'contextmenu', () => {
    try {
      chrome.runtime.sendMessage({ kind: 'menu-opening', pageUrl: location.href },
        () => { void chrome.runtime.lastError; });
    } catch (_) {}
  }, true);

  woOnMessage((msg) => {
    if (!msg || msg.kind !== 'hidden-rules-refresh') return;
    bridgeLoadUserHidden();
  });

  // MAIN-world events are visible to the page and must be treated as untrusted.
  // Keep useful diagnostics, but never let a page enqueue megabytes of nested
  // data into extension messaging/history storage.
  function boundedBridgeDetail(value) {
    const seen = new WeakSet();
    const budget = { chars: 0 };
    const copy = (input, depth) => {
      if (input == null || typeof input === 'boolean') return input;
      if (typeof input === 'number') return Number.isFinite(input) ? input : 0;
      if (typeof input === 'string') {
        const text = input.slice(0, 600);
        budget.chars += text.length;
        return budget.chars <= 6000 ? text : '';
      }
      if (depth >= 2 || (typeof input !== 'object' && !Array.isArray(input))) return undefined;
      if (seen.has(input)) return undefined;
      seen.add(input);
      if (Array.isArray(input)) {
        const out = [];
        for (let i = 0; i < input.length && i < 16 && budget.chars <= 6000; i++) {
          const item = copy(input[i], depth + 1);
          if (item !== undefined) out.push(item);
        }
        return out;
      }
      const out = {};
      let count = 0;
      for (const key of Object.keys(input)) {
        if (count++ >= 24 || budget.chars > 6000) break;
        const cleanKey = String(key).slice(0, 80);
        budget.chars += cleanKey.length;
        let item;
        try { item = copy(input[key], depth + 1); } catch (_) { item = undefined; }
        if (item !== undefined) out[cleanKey] = item;
      }
      return out;
    };
    try { return copy(value, 0); } catch (_) { return null; }
  }

  function pageTargetOrigin() {
    try {
      if ((location.protocol === 'http:' || location.protocol === 'https:') && location.origin && location.origin !== 'null') {
        return location.origin;
      }
    } catch (_) {}
    return '*';
  }

  function postToPage(message) {
    try { window.postMessage(message, pageTargetOrigin()); } catch (_) {}
  }

  function publicSafeBrowsingResult(res) {
    const r = res && typeof res === 'object' ? res : { ok: false, error: 'No Safe Browsing response' };
    return {
      ok: !!r.ok,
      enabled: !!r.enabled,
      hit: !!r.hit,
      warning: !!r.warning,
      cached: !!r.cached,
      timeout: !!r.timeout,
      error: r.error ? String(r.error).slice(0, 120) : '',
    };
  }

  const WO_MODAL = {
    overlay: (align) => 'all:initial!important;position:fixed!important;inset:0!important;z-index:2147483647!important;display:flex!important;align-items:center!important;justify-content:center!important;background:rgba(61,42,82,.48)!important;color:#3d2a52!important;padding:24px!important;font-family:Nunito,system-ui,sans-serif!important;text-align:' + (align || 'left') + '!important;backdrop-filter:blur(10px) saturate(1.2)!important;-webkit-backdrop-filter:blur(10px) saturate(1.2)!important;',
    panel: (width, gap) => 'all:initial!important;box-sizing:border-box!important;display:flex!important;flex-direction:column!important;gap:' + (gap || '13px') + '!important;max-width:' + (width || '680px') + '!important;width:min(' + (width || '680px') + ',calc(100vw - 32px))!important;border:1px solid rgba(176,106,212,.34)!important;border-left:4px solid #9d54c9!important;border-radius:16px!important;background:linear-gradient(135deg,#faf2fe,#f4e9fb)!important;color:#3d2a52!important;padding:22px!important;box-shadow:0 24px 90px rgba(120,55,160,.32)!important;font-family:Nunito,system-ui,sans-serif!important;',
    title: 'all:initial!important;color:#3d2a52!important;font:800 18px/1.25 Nunito,system-ui,sans-serif!important;',
    body: 'all:initial!important;color:#5f456f!important;font:600 14px/1.5 Nunito,system-ui,sans-serif!important;',
    meta: 'all:initial!important;color:#7a5f93!important;font:700 12px/1.45 Nunito,system-ui,sans-serif!important;background:#ede1f8!important;border:1px solid rgba(176,106,212,.22)!important;border-radius:9px!important;padding:9px 10px!important;word-break:break-word!important;',
    actions: (justify) => 'all:initial!important;display:flex!important;gap:9px!important;justify-content:' + (justify || 'flex-end') + '!important;flex-wrap:wrap!important;font-family:Nunito,system-ui,sans-serif!important;',
    status: 'all:initial!important;color:#7a5f93!important;font:700 12px/1.4 Nunito,system-ui,sans-serif!important;min-height:16px!important;',
    tag: (risk) => 'all:initial!important;align-self:flex-start!important;border-radius:999px!important;background:' + (/^high$/i.test(String(risk || '')) ? 'linear-gradient(135deg,#d868a2,#9d54c9)' : 'linear-gradient(135deg,#b06ad4,#e07ab0)') + '!important;color:#fff!important;padding:4px 9px!important;font:800 11px/1 Nunito,system-ui,sans-serif!important;box-shadow:0 6px 16px rgba(157,84,201,.22)!important;',
    button: (primary, size) => 'all:initial!important;box-sizing:border-box!important;border:' + (primary ? 'none' : '1px solid rgba(176,106,212,.38)') + '!important;background:' + (primary ? 'linear-gradient(135deg,#b06ad4,#e07ab0)' : 'rgba(61,42,82,.06)') + '!important;color:' + (primary ? '#fff' : '#5f456f') + '!important;cursor:pointer!important;border-radius:9px!important;padding:10px 14px!important;font:800 ' + (size || '12px') + '/1 Nunito,system-ui,sans-serif!important;box-shadow:' + (primary ? '0 8px 20px rgba(157,84,201,.26)' : 'none') + '!important;',
  };

  function bridgePrivateOrLocalHost(host) {
    const h = String(host || '').trim().toLowerCase().replace(/^\[|\]$/g, '').replace(/\.$/, '');
    if (!h || h.includes('%')) return true;
    if (/^(localhost|0\.0\.0\.0|127(?:\.\d{1,3}){0,3}|::1)$/i.test(h)) return true;
    const ipv4 = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
    if (ipv4) {
      const a = Number(ipv4[1]), b = Number(ipv4[2]), c = Number(ipv4[3]), d = Number(ipv4[4]);
      if ([a, b, c, d].some((n) => n < 0 || n > 255)) return true;
      if (a === 10 || a === 127 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 169 && b === 254)) return true;
      if (a === 100 && b >= 64 && b <= 127) return true;
      if (a === 192 && b === 0 && c === 2) return true;
      if (a === 198 && (b === 18 || b === 19)) return true;
      if (a === 198 && b === 51 && c === 100) return true;
      if (a === 203 && b === 0 && c === 113) return true;
      return false;
    }
    if (h.includes(':')) return true;
    if (!h.includes('.')) return true;
    const tld = h.split('.').pop();
    return /^(local|localhost|lan|home|internal|intranet|corp|test|invalid|example)$/i.test(tld);
  }

  // normalizeBridgeHost is pure, and its cost is dominated by the new URL() it builds.
  // sendConfig runs it over the same host lists more than once per call and again on
  // every config change, so the answers are memoised. Bounded because a hostile page
  // cannot reach this, but a very large user-supplied list could otherwise grow it
  // without limit.
  const NORMALIZED_HOST_CACHE = new Map();
  const NORMALIZED_HOST_CACHE_MAX = 12000;
  function normalizeBridgeHost(value) {
    const key = typeof value === 'string' ? value : String(value || '');
    const cached = NORMALIZED_HOST_CACHE.get(key);
    if (cached !== undefined) return cached;
    const computed = normalizeBridgeHostUncached(value);
    if (NORMALIZED_HOST_CACHE.size >= NORMALIZED_HOST_CACHE_MAX) NORMALIZED_HOST_CACHE.clear();
    NORMALIZED_HOST_CACHE.set(key, computed);
    return computed;
  }

  function normalizeBridgeHostUncached(value) {
    let raw = String(value || '').trim();
    if (!raw || raw.length > 512) return '';
    try {
      if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) {
        const u = new URL(raw);
        if (u.protocol !== 'http:' && u.protocol !== 'https:') return '';
        raw = u.hostname;
      } else {
        raw = new URL('https://' + raw).hostname;
      }
    } catch (_) {
      if (/[/?#]/.test(raw)) return '';
    }
    const h = raw.toLowerCase().replace(/^www\./, '').replace(/^\.+|\.+$/g, '');
    if (!h || h.length > 253 || h.includes('*') || h.includes('%') || h.includes('/') || h.includes('\\')) return '';
    if (!/^[a-z0-9.-]+$/i.test(h) || h.includes('..') || bridgePrivateOrLocalHost(h)) return '';
    const labels = h.split('.');
    if (labels.length < 2) return '';
    if (labels.some((label) => !label || label.length > 63 || /^-|-$/.test(label))) return '';
    return h;
  }

  function sanitizeBridgeHostList(list, limit) {
    const out = [];
    const seen = new Set();
    const max = Math.max(1, Math.min(Number(limit) || 1000, 5000));
    (Array.isArray(list) ? list : []).forEach((item) => {
      if (out.length >= max) return;
      const h = normalizeBridgeHost(item);
      if (!h || seen.has(h)) return;
      seen.add(h);
      out.push(h);
    });
    return out;
  }

  // Hand the token to the main world once, immediately. content.js captures the
  // first token it sees at document_start and locks it in.
  postToPage({ source: 'wardenone-handshake', token: TOKEN });

  let learnedGrabberDomains = [];
  let supplementalLists = { adultDomainsExtra: [], grabberDomainsExtra: [], trustedPaymentHostsExtra: [] };
  let bridgeConfig = {};
  let bridgeConfigReady = false;
  // This frame's own site as the worker computed it from the complete suffix list, '' until the
  // config answer names it. The guard's same-party test reads it from the signed config (SEC-07).
  let bridgeFrameSite = '';

  // ---- Shared DOM watcher ----
  // Smart Script Shield, Script Drift and the Login Page Age check each ran their
  // own whole-document subtree MutationObserver, two of them for a full 60 seconds
  // on every top-level page. That fired three separate extension callbacks for every
  // mutation batch during the busiest minute of a page's life -- all to answer the
  // same question: did the DOM change?
  //
  // They share one observer now. Subscribers are deliberately independent: one
  // unsubscribing must never stop the others, so the observer is disconnected only
  // when the LAST subscriber leaves, and reconnected if one arrives afterwards
  // (Smart Script Shield re-arms on popstate/hashchange, long after the others are
  // finished). Records are passed through because Script Drift reads addedNodes.
  const domWatchers = new Set();
  const domElementWatchers = new Set();
  let domObserver = null;
  let domWatchPending = false;

  function domWatchStart() {
    if (domObserver || !domWatchers.size) return;
    const root = document.documentElement;
    if (!root) {
      // A document whose element is not up yet at document_start. Try once more.
      if (domWatchPending) return;
      domWatchPending = true;
      try {
        woOn(document, 'DOMContentLoaded', () => {
          domWatchPending = false;
          domWatchStart();
        }, { once: true });
      } catch (_) { domWatchPending = false; }
      return;
    }
    try {
      domObserver = woObserver((records) => {
        let structural = false;
        if (domElementWatchers.size) {
          structural = domRecordsHaveElementMutation(records);
          if (!structural && domElementWatchers.size === domWatchers.size) return;
        }
        // Snapshot the set: a subscriber may unsubscribe from inside its own
        // callback (the login-age watcher does), and one throwing must not stop the
        // rest from being told.
        for (const fn of Array.from(domWatchers)) {
          if (!structural && domElementWatchers.has(fn)) continue;
          try { fn(records); } catch (_) {}
        }
      });
      domObserver.observe(root, {
        childList: true,
        subtree: true,
        attributes: true,
        attributeFilter: ['type'],
      });
    } catch (_) {
      domObserver = null;
    }
  }

  function domWatchStop() {
    if (!domObserver) return;
    try { domObserver.disconnect(); } catch (_) {}
    domObserver = null;
  }

  // Returns an unsubscribe function. Safe to call more than once.
  function domWatch(fn, elementsOnly) {
    if (typeof fn !== 'function') return function () {};
    domWatchers.add(fn);
    if (elementsOnly) domElementWatchers.add(fn);
    domWatchStart();
    let released = false;
    return function () {
      if (released) return;
      released = true;
      domWatchers.delete(fn);
      domElementWatchers.delete(fn);
      if (!domWatchers.size) domWatchStop();
    };
  }

  /* Login and other selector-based checks need a new or removed element, or an
     existing input becoming a password field, not a text node changing from one
     player counter value to the next. Removals count: warning durability may need
     to put an owned element back. */
  function domRecordsHaveElementMutation(records) {
    for (const record of records || []) {
      if (record && record.type === 'attributes' && record.attributeName === 'type'
          && record.target && String(record.target.tagName || '').toUpperCase() === 'INPUT') {
        return true;
      }
      const added = (record && record.addedNodes) || [];
      for (let i = 0; i < added.length; i++) {
        if (added[i] && added[i].nodeType === 1) return true;
      }
      const removed = (record && record.removedNodes) || [];
      for (let i = 0; i < removed.length; i++) {
        if (removed[i] && removed[i].nodeType === 1) return true;
      }
    }
    return false;
  }

  // Page-owned selectors and IDs cannot authorize WardenOne controls.
  // Keep direct node references in closed shadow roots; public host markers
  // remain labels for styling and exclusions, never credentials.
  const WO_OWNED_HOST_STYLE = 'all:initial!important;position:fixed!important;inset:auto!important;'
    + 'z-index:2147483647!important;';

  // The focus ring, painted inline rather than declared in a stylesheet.
  //
  // The warnings reset their buttons with `all:initial!important` in the style attribute to strip
  // page CSS, and that takes the focus ring with it, so a keyboard user cannot see which action is
  // selected. The obvious repair -- a `:focus-visible` rule in the overlay's own stylesheet -- does
  // not work, and it is not a specificity problem to out-specify: an important declaration in a
  // style attribute beats an important rule from any stylesheet, shadow root included. Measured in
  // Chromium, every button still computed to `outline-style:none`, so the ring the code claimed to
  // restore never drew.
  //
  // Setting the property inline puts it in the same declaration block as the reset, where the later
  // declaration wins. An outline in `currentColor` is what forced-colors mode honours; a coloured
  // box-shadow is discarded there.
  //
  // `scope` must be the node the focus events reach WITHOUT being retargeted -- the shadow root for
  // an owned overlay, the host itself only in the light-DOM fallback. Bound on the host instead,
  // every focusin from inside a closed shadow root arrives reporting the host as its target, so the
  // ring would follow nothing and land on nothing. Measured: Tab moved between buttons and no ring
  // was drawn at all.
  function woFocusRing(scope) {
    let painted = null;
    const drop = () => {
      if (!painted) return;
      try {
        painted.style.removeProperty('outline');
        painted.style.removeProperty('outline-offset');
      } catch (_) {}
      painted = null;
    };
    const paint = (el) => {
      drop();
      if (!el || !el.style) return;
      try {
        el.style.setProperty('outline', '3px solid currentColor', 'important');
        el.style.setProperty('outline-offset', '2px', 'important');
        painted = el;
      } catch (_) {}
    };
    // :focus-visible is the browser's own answer to "did a keyboard put focus here?", so ask it
    // rather than reimplementing the heuristic. A mouse click should not leave a ring behind.
    const onIn = (e) => {
      const target = e && e.target;
      let visible = true;
      try { visible = !target.matches || target.matches(':focus-visible'); } catch (_) {}
      if (visible) paint(target);
      else drop();
    };
    const onOut = () => drop();
    try {
      scope.addEventListener('focusin', onIn, true);
      scope.addEventListener('focusout', onOut, true);
    } catch (_) {}
    return {
      paint,
      release() {
        drop();
        try {
          scope.removeEventListener('focusin', onIn, true);
          scope.removeEventListener('focusout', onOut, true);
        } catch (_) {}
      },
    };
  }

  function woOwnedOverlay(id) {
    let host = null;
    let shadow = null;
    let unwatch = null;
    let gone = false;
    let restoreFocusTo = null;
    let trapHandler = null;
    let focusRing = null;
    let dialogFocus = null;

    const container = () => document.body || document.documentElement || null;

    function build() {
      host = document.createElement('div');
      try {
        host.id = id;
        host.setAttribute('data-wo-ui', '1');
        host.setAttribute('style', WO_OWNED_HOST_STYLE);
      } catch (_) {}
      // If attachShadow is unavailable or the page has broken it, fall back to rendering into
      // the host directly. That is the old, weaker arrangement rather than no warning at all --
      // for the interstitials, being removable beats being invisible.
      try {
        shadow = host.attachShadow({ mode: 'closed' });
      } catch (_) {
        shadow = host;
      }
      return shadow;
    }

    function place() {
      const parent = container();
      if (!parent || !host) return false;
      try {
        if (host.parentNode !== parent) {
          parent.appendChild(host);
          // Re-parenting drops focus from a closed shadow tree. A page can remove a
          // warning host, so restoring the host also has to restore its modal focus.
          if (dialogFocus) {
            try { dialogFocus.focus(); } catch (_) { try { host.focus(); } catch (_) {} }
          }
        }
        return true;
      } catch (_) {
        return false;
      }
    }

    const api = {
      // The shadow root to render into. Built on first use.
      root() { return shadow || build(); },
      // The node identity check: only nodes we created live in our shadow root.
      owns(node) {
        if (!node || !shadow) return false;
        try {
          // getRootNode() on a node inside a closed shadow root returns that root, and a page
          // cannot obtain it -- so a decoy in the page's DOM can never satisfy this.
          return node.getRootNode() === shadow;
        } catch (_) {
          return false;
        }
      },
      mount() {
        if (gone) return false;
        if (!shadow) build();
        const placed = place();
        // Self-healing. A page that removes the host gets it put straight back; the warning it
        // is trying to delete is about that page. Re-placing is cheap because the node and its
        // shadow tree are kept, so nothing is rebuilt.
        if (placed && !unwatch) {
          unwatch = domWatch(() => {
            if (gone || !host) return;
            try {
              if (!host.isConnected) place();
            } catch (_) {}
          }, true);
        }
        return placed;
      },
      // Make this overlay behave as the modal it already looks like (M20).
      //
      // Called after the contents exist, because the accessible name has to point at a heading that
      // is already there. The W3C pattern is explicit that aria-modal must not be set on something
      // that does not actually behave modally, so the semantics and the keyboard containment are
      // applied together here rather than separately.
      dialog(opts) {
        const o = opts || {};
        if (!shadow || !host) return false;
        try {
          const box = document.createElement('div');
          box.setAttribute('role', 'alertdialog');
          box.setAttribute('aria-modal', 'true');
          box.setAttribute('tabindex', '-1');
          if (o.label) box.setAttribute('aria-label', String(o.label));
          if (o.description) box.setAttribute('aria-description', String(o.description));
          box.setAttribute('style', 'all:initial!important;display:block!important;');
          // Re-parent what the caller already rendered, so callers keep building their own markup
          // and gain the semantics without knowing about them.
          while (shadow.firstChild) box.appendChild(shadow.firstChild);
          shadow.appendChild(box);
          // The shadow root, not the host: focus events are retargeted as they leave a closed
          // shadow tree, so a listener on the host only ever sees the host.
          focusRing = woFocusRing(shadow);

          const focusables = () => {
            try {
              return Array.prototype.slice.call(box.querySelectorAll(
                'button,[href],input,select,textarea,[tabindex]:not([tabindex="-1"])',
              )).filter((n) => !n.disabled && !n.hidden && n.getAttribute('aria-hidden') !== 'true'
                && n.getAttribute('tabindex') !== '-1' && n.offsetParent !== null);
            } catch (_) { return []; }
          };

          // Remember where focus was so it can be handed back. A warning that steals focus and
          // never returns it leaves a keyboard user stranded on a page they were reading.
          try { restoreFocusTo = document.activeElement; } catch (_) { restoreFocusTo = null; }

          // Focus the safest action if the caller named one, otherwise the container. Never the
          // destructive action -- a warning that opens with "continue anyway" focused is a warning
          // that can be dismissed by a reflexive Enter.
          try {
            host.setAttribute('tabindex', '-1');
            const list = focusables();
            const chosen = o.focus && box.querySelector(o.focus);
            const first = (chosen && list.includes(chosen) && chosen) || list[0] || box;
            dialogFocus = first;
            if (first && first.focus) first.focus();
            // The dialog took focus without being asked to, so show where it went. From here on the
            // ring follows :focus-visible, which is what keeps a mouse click from leaving one.
            if (first && first !== box) focusRing.paint(first);
          } catch (_) {}

          // Contain Tab inside the dialog. Bound on the host, not the document, and removed in
          // destroy() below -- a trap that outlives its dialog breaks the page it was warning about.
          trapHandler = (e) => {
            if (gone || !e || e.key !== 'Tab') return;
            const list = focusables();
            if (!list.length) { e.preventDefault(); return; }
            const firstEl = list[0];
            const lastEl = list[list.length - 1];
            let active = null;
            try { active = shadow.activeElement || null; } catch (_) {}
            if (e.shiftKey && (active === firstEl || !active)) {
              e.preventDefault();
              try { lastEl.focus(); } catch (_) {}
            } else if (!e.shiftKey && active === lastEl) {
              e.preventDefault();
              try { firstEl.focus(); } catch (_) {}
            }
          };
          host.addEventListener('keydown', trapHandler, true);
          return true;
        } catch (_) {
          return false;
        }
      },
      destroy() {
        // Idempotent, and always deregisters: dispose drains the set and a caller may destroy
        // the same overlay first, so neither may depend on being the one that got there.
        woOverlays.delete(api);
        gone = true;
        if (unwatch) { try { unwatch(); } catch (_) {} unwatch = null; }
        // Before the host goes: release the keyboard and hand focus back. Both must happen on
        // every close path, which is why they live here rather than in each caller's dismiss
        // handler -- there are more close paths than dismiss buttons.
        if (trapHandler && host) {
          try { host.removeEventListener('keydown', trapHandler, true); } catch (_) {}
        }
        trapHandler = null;
        if (focusRing) { try { focusRing.release(); } catch (_) {} focusRing = null; }
        try { if (host) host.remove(); } catch (_) {}
        if (restoreFocusTo && restoreFocusTo.focus && restoreFocusTo.isConnected) {
          try { restoreFocusTo.focus(); } catch (_) {}
        }
        restoreFocusTo = null;
        dialogFocus = null;
        host = null;
        shadow = null;
      },
      // Only for our own bookkeeping; conveys no trust.
      hostNode() { return host; },
    };
    woOverlays.add(api);
    return api;
  }

  // Handles for the three interstitials, so replacing one destroys the overlay we built rather
  // than whatever the page currently has under that id.
  let scriptDriftOverlay = null;
  let permChainOverlay = null;
  let loginAgeOverlay = null;

  // MAIN can cancel an action, but a hostile page owns its light DOM. Keep an independent
  // copy of its high-stakes warning in this isolated world so removing or counterfeiting
  // the MAIN panel does not make the warning disappear. The signed event carries only
  // an ID. Every word in this copy comes from ISOLATED, not page-tamperable MAIN text.
  const mainWarningCopy = Object.freeze({
    'wo-sb-block': 'A destination was flagged as dangerous. WardenOne stopped the action.',
    'wo-clip-swap': 'A page tried to change a copied address. Check what you paste.',
    'wo-scam-lock': 'This page shows signs of a scam. Do not follow its payment or verification instructions.',
    'wo-cmd-warn': 'This page may be asking you to run a dangerous command. Do not paste commands into a terminal or the Run dialog.',
    'wo-paste-warn': 'You were about to paste a password or token into a risky field. The paste was stopped.',
    'wo-formtrap-warn': 'This form has warning signs. Check the site and the destination before entering sensitive data.',
    'wo-insecure-login': 'This sign-in may send your password without encryption. Check the address before continuing.',
    'wo-fake-window': 'This page may be imitating a browser or system window. Check the real address bar.',
    'wo-fullscreen-spoof': 'This page may be using fullscreen to imitate your browser. Exit fullscreen and check the address bar.',
  });
  const mainWarningText = new Map();
  let mainWarningOverlay = null;
  let mainWarningChecks = [];
  function ownedWarningIsVisible(overlay, card) {
    const host = overlay.hostNode();
    if (!host || !host.isConnected) return false;
    try {
      const rect = card.getBoundingClientRect();
      for (let node = host; node && node.nodeType === 1; node = node.parentElement) {
        const style = getComputedStyle(node);
        if (style.display === 'none' || style.visibility !== 'visible' || Number(style.opacity) < 0.5) return false;
        const filter = String(style.filter || 'none');
        const blur = /\bblur\(\s*([\d.]+)px\s*\)/i.exec(filter);
        const brightness = /\bbrightness\(\s*([\d.]+)(%)?\s*\)/i.exec(filter);
        const opacity = /\bopacity\(\s*([\d.]+)(%)?\s*\)/i.exec(filter);
        if ((blur && Number(blur[1]) >= 4)
          || (brightness && Number(brightness[1]) < (brightness[2] ? 35 : 0.35))
          || (opacity && Number(opacity[1]) < (opacity[2] ? 50 : 0.5))) return false;
      }
      if (rect.width <= 0 || rect.height <= 0) return false;
      const points = [[0.5, 0.12], [0.25, 0.5], [0.75, 0.5], [0.5, 0.88]];
      let visible = 0;
      for (const [fx, fy] of points) {
        const x = rect.left + rect.width * fx;
        const y = rect.top + rect.height * fy;
        if (x < 0 || y < 0 || x >= window.innerWidth || y >= window.innerHeight) continue;
        const hit = document.elementFromPoint(x, y);
        if (hit === host || host.contains(hit)) visible++;
      }
      return visible >= 3;
    } catch (_) { return false; }
  }
  function clearMainWarningChecks() {
    for (const cancel of mainWarningChecks) cancel();
    mainWarningChecks = [];
  }
  function showOwnedMainWarning(detail) {
    const id = String(detail && detail.id || '');
    const decisionId = Number(detail && detail.decisionId);
    if (!Object.prototype.hasOwnProperty.call(mainWarningCopy, id)) return;
    const message = mainWarningCopy[id];
    if (!message) return;
    if (mainToastOverlay) closeOwnedToast(mainToastOverlay);
    if (mainWarningText.has(id)) mainWarningText.delete(id);
    mainWarningText.set(id, message);
    while (mainWarningText.size > 6) mainWarningText.delete(mainWarningText.keys().next().value);
    clearMainWarningChecks();
    if (mainWarningOverlay) mainWarningOverlay.destroy();
    const overlay = mainWarningOverlay = woOwnedOverlay('wo-owned-main-warning');
    const root = overlay.root();
    // Dressed like the page engine's own warning panels (the clipboard-swap and fake-window
    // cards): the same alert border and tag, Quicksand and Nunito, and WardenOne's pink-purple
    // button, so a blocking warning from either half looks like one product.
    const card = document.createElement('div');
    card.setAttribute('style', 'all:initial!important;box-sizing:border-box!important;position:fixed!important;'
      + 'top:24px!important;left:50%!important;transform:translateX(-50%)!important;'
      + 'width:min(480px,calc(100vw - 32px))!important;max-height:70vh!important;overflow:auto!important;'
      + 'padding:16px 18px!important;border:2px solid #c0392b!important;border-radius:16px!important;'
      + 'background:rgba(255,247,247,.99)!important;color:#2d1b40!important;'
      + 'box-shadow:0 18px 52px rgba(120,20,20,.4)!important;'
      + 'font:13px/1.5 "Nunito",-apple-system,"Segoe UI",system-ui,sans-serif!important;');
    const heading = document.createElement('strong');
    heading.setAttribute('style', 'all:initial!important;display:inline-block!important;'
      + 'background:rgba(192,57,43,.14)!important;color:#c0392b!important;padding:3px 9px!important;border-radius:8px!important;'
      + 'font:700 11px/1.4 "Quicksand",system-ui,sans-serif!important;letter-spacing:.04em!important;'
      + 'text-transform:uppercase!important;margin-bottom:6px!important;');
    heading.textContent = 'WardenOne warning';
    card.appendChild(heading);
    for (const warning of mainWarningText.values()) {
      const item = document.createElement('p');
      item.setAttribute('style', 'all:initial!important;display:block!important;'
        + 'font:12.5px/1.55 "Nunito",-apple-system,"Segoe UI",system-ui,sans-serif!important;color:#4a3661!important;'
        + 'margin:8px 0!important;white-space:normal!important;overflow-wrap:anywhere!important;');
      item.textContent = warning;
      card.appendChild(item);
    }
    const button = document.createElement('button');
    button.type = 'button';
    button.setAttribute('style', 'all:initial!important;display:block!important;box-sizing:border-box!important;'
      + 'width:100%!important;cursor:pointer!important;text-align:center!important;'
      + 'background:linear-gradient(135deg,#b06ad4,#e07ab0)!important;color:#fff!important;padding:10px 14px!important;'
      + 'border-radius:10px!important;font:700 12.5px "Quicksand",system-ui,sans-serif!important;margin-top:12px!important;');
    button.textContent = 'I understand';
    const onAcknowledge = (e) => {
      if (!e.isTrusted || mainWarningOverlay !== overlay || !overlay.owns(button)) return;
      clearMainWarningChecks();
      mainWarningText.clear();
      mainWarningOverlay = null;
      overlay.destroy();
    };
    button.addEventListener('click', onAcknowledge);
    card.appendChild(button);
    let continuePaste = null;
    let onContinuePaste = null;
    if (id === 'wo-paste-warn' && Number.isSafeInteger(decisionId) && decisionId > 0) {
      continuePaste = document.createElement('button');
      continuePaste.type = 'button';
      continuePaste.setAttribute('style', 'all:initial!important;display:block!important;box-sizing:border-box!important;'
        + 'width:100%!important;cursor:pointer!important;text-align:center!important;'
        + 'background:#fff!important;color:#7a3fa8!important;padding:9px 14px!important;'
        + 'border:1px solid #d9b8ee!important;border-radius:10px!important;'
        + 'font:700 12.5px "Quicksand",system-ui,sans-serif!important;margin-top:8px!important;');
      continuePaste.textContent = 'Paste anyway';
      onContinuePaste = (e) => {
        if (!e.isTrusted || mainWarningOverlay !== overlay || !overlay.owns(continuePaste)) return;
        if (!dispatchWarningDecision(id, decisionId)) return;
        clearMainWarningChecks();
        mainWarningText.clear();
        mainWarningOverlay = null;
        overlay.destroy();
      };
      continuePaste.addEventListener('click', onContinuePaste);
      card.appendChild(continuePaste);
    }
    const destroyOwnedWarning = overlay.destroy.bind(overlay);
    overlay.destroy = () => {
      button.removeEventListener('click', onAcknowledge);
      if (continuePaste) continuePaste.removeEventListener('click', onContinuePaste);
      destroyOwnedWarning();
    };
    root.appendChild(card);
    overlay.mount();
    overlay.dialog({ label: 'WardenOne warning', focus: 'button' });
    let reportedOcclusion = false;
    const checkVisible = () => {
      if (mainWarningOverlay !== overlay || reportedOcclusion) return;
      if (!overlay.hostNode()) { clearMainWarningChecks(); mainWarningOverlay = null; return; }
      if (ownedWarningIsVisible(overlay, card)) return;
      reportedOcclusion = true;
      clearMainWarningChecks();
      try { chrome.runtime.sendMessage({ kind: 'warning-ui-compromised' }, () => { void chrome.runtime.lastError; }); } catch (_) {}
    };
    for (const delay of [200, 800, 2500, 6000]) {
      const timer = woTimeout(checkVisible, delay);
      mainWarningChecks.push(() => clearTimeout(timer));
    }
    const interval = woInterval(checkVisible, 10000);
    mainWarningChecks.push(() => clearInterval(interval));
  }

  /* Toasts whose loss would hide a security decision get a small independent copy.
     MAIN decides whether a toast is enabled or muted, then signs only its type.
     The page cannot supply wording or a decision action to this copy. */
  const mainToastCopy = Object.freeze({
    blocked_safe_browsing_link: 'WardenOne blocked a dangerous link.',
    blocked_safe_browsing_form: 'WardenOne blocked a form on a dangerous page.',
    blocked_safe_browsing_paste: 'WardenOne stopped a secret paste on a dangerous page.',
    blocked_token_exfil: 'WardenOne blocked a token-shaped value leaving this site.',
    blocked_skimmer_exfil: 'WardenOne blocked card or password data leaving this page.',
    blocked_payment_card_submit: 'WardenOne stopped card details from being sent by this checkout.',
    warned_confirm_bait: 'This page showed a fake confirmation box. Do not follow its instructions.',
    warned_notification_scam: 'This site raised a notification that resembles a fake alert.',
    warned_device_request: 'This site requested access to a device. Choose one only if you intended to.',
    warned_device_silent: 'This site used a device you allowed on an earlier visit.',
    blocked_speech_capture: 'WardenOne blocked speech recognition through your microphone.',
    warned_file_silent: 'This site used file access you allowed on an earlier visit.',
    warned_file_request: 'This site requested a file or folder. Choose one only if you intended to.',
    warned_speech_capture: 'This site started speech recognition. Leave if you did not start it.',
    warned_fake_window: 'This page may be imitating a sign-in window. Check the real address bar.',
    warned_fullscreen_spoof: 'This page may be imitating the browser in fullscreen. Exit fullscreen first.',
    blocked_media_capture: 'WardenOne blocked an unexpected camera or microphone request.',
    blocked_screen_capture: 'WardenOne blocked an unexpected screen capture request.',
    warned_media_capture: 'This site requested camera or microphone access.',
    warned_hidden_media_capture: 'This site requested camera or microphone access without a recent click.',
    warned_screen_capture: 'This site requested screen capture access.',
    warned_hidden_screen_capture: 'This site requested screen capture without a recent click.',
    warned_abuseipdb_server: 'An external reputation provider reported this server as suspicious.',
    warned_url_reputation: 'An external reputation provider reported this URL as suspicious.',
    warned_phishing: 'This site resembles a well-known brand. Check the real address before signing in.',
    warned_payment_card_entry: 'This checkout has payment-risk signals. Check its address before continuing.',
    warned_fake_update: 'This page offers a fake browser or system update. Do not run its download.',
    warned_honeytoken_read: 'A page script read a decoy credential. Be careful what you enter here.',
  });
  let mainToastOverlay = null;
  let mainToastChecks = [];
  const mainToastText = new Map();
  function closeOwnedToast(overlay, clearText = true) {
    if (mainToastOverlay !== overlay) return;
    for (const cancel of mainToastChecks) cancel();
    mainToastChecks = [];
    mainToastOverlay = null;
    if (clearText) mainToastText.clear();
    overlay.destroy();
  }
  function showOwnedMainToast(detail) {
    const id = String(detail && detail.id || '');
    if (!Object.prototype.hasOwnProperty.call(mainToastCopy, id) || mainWarningOverlay) return;
    if (mainToastText.has(id)) mainToastText.delete(id);
    mainToastText.set(id, mainToastCopy[id]);
    while (mainToastText.size > 4) mainToastText.delete(mainToastText.keys().next().value);
    if (mainToastOverlay) closeOwnedToast(mainToastOverlay, false);
    const overlay = mainToastOverlay = woOwnedOverlay('wo-owned-security-toast');
    const root = overlay.root();
    // Dressed exactly like the page engine's own toast (lavender card, purple edge, Quicksand
    // title) so it reads as WardenOne, not as a different product's alert.
    const card = document.createElement('div');
    card.setAttribute('role', 'alert');
    card.setAttribute('style', 'all:initial!important;box-sizing:border-box!important;position:fixed!important;'
      + 'top:16px!important;right:16px!important;width:min(340px,calc(100vw - 32px))!important;'
      + 'max-height:55vh!important;overflow:auto!important;padding:13px 15px!important;'
      + 'border-left:4px solid #9d54c9!important;border-radius:14px!important;'
      + 'background:linear-gradient(135deg,#faf2fe,#f4e9fb)!important;color:#3d2a52!important;'
      + 'box-shadow:0 8px 28px rgba(120,55,160,.26)!important;'
      + 'font:13px/1.45 "Nunito",-apple-system,"Segoe UI",system-ui,sans-serif!important;');
    const heading = document.createElement('strong');
    heading.setAttribute('style', 'all:initial!important;display:block!important;'
      + 'font:700 13.5px/1.3 "Quicksand","Nunito",system-ui,sans-serif!important;color:#3d2a52!important;margin-bottom:2px!important;');
    heading.textContent = 'WardenOne warning';
    card.appendChild(heading);
    for (const copy of mainToastText.values()) {
      const message = document.createElement('span');
      message.setAttribute('style', 'all:initial!important;display:block!important;'
        + 'font:12px/1.45 "Nunito",-apple-system,"Segoe UI",system-ui,sans-serif!important;color:#7a5f93!important;margin:4px 0!important;');
      message.textContent = copy;
      card.appendChild(message);
    }
    const button = document.createElement('button');
    button.type = 'button';
    button.setAttribute('style', 'all:initial!important;display:inline-block!important;cursor:pointer!important;'
      + 'margin-top:8px!important;padding:2px 8px!important;border-radius:7px!important;'
      + 'border:1px solid #e0cff0!important;background:#f2e9f9!important;color:#5d3f78!important;'
      + 'font:600 11px/16px "Nunito",system-ui,sans-serif!important;');
    button.textContent = 'Dismiss';
    const dismiss = (e) => { if (e.isTrusted && overlay.owns(button)) closeOwnedToast(overlay); };
    button.addEventListener('click', dismiss);
    card.appendChild(button);
    const originalDestroy = overlay.destroy.bind(overlay);
    overlay.destroy = () => { button.removeEventListener('click', dismiss); originalDestroy(); };
    root.appendChild(card);
    overlay.mount();
    let reported = false;
    const check = () => {
      if (mainToastOverlay !== overlay || reported || ownedWarningIsVisible(overlay, card)) return;
      reported = true;
      try { chrome.runtime.sendMessage({ kind: 'warning-ui-compromised' }, () => { void chrome.runtime.lastError; }); } catch (_) {}
    };
    for (const delay of [200, 800, 2500, 6000]) {
      const timer = woTimeout(check, delay);
      mainToastChecks.push(() => clearTimeout(timer));
    }
    const interval = woInterval(check, 10000);
    mainToastChecks.push(() => clearInterval(interval));
    const expiry = woTimeout(() => closeOwnedToast(overlay), 15000);
    mainToastChecks.push(() => clearTimeout(expiry));
  }

  // Smart Script Shield recovery is deliberately driven by this isolated-world
  // signal, not by a page-visible CustomEvent. The evidence is intentionally
  // narrow: an actual video, a recognised player library root, or a media-route
  // page containing a fullscreen/autoplay embed. Background still requires a
  // matching third-party script ERR_BLOCKED_BY_CLIENT before changing any rule.
  let smartPlayerEvidence = '';
  let smartPlayerLastSignalAt = 0;
  let smartPlayerScanCount = 0;
  let smartPlayerScanTimer = null;
  let smartPlayerUnwatch = null;
  let smartPlayerObserverGeneration = 0;
  let smartPlayerHeartbeat = null;
  const SMART_PLAYER_HEARTBEAT_MAX = 15;
  function stopSmartPlayerHeartbeat() {
    if (!smartPlayerHeartbeat) return;
    try { clearInterval(smartPlayerHeartbeat); } catch (_) {}
    smartPlayerHeartbeat = null;
  }
  function smartPlayerRoute(rawUrl) {
    try {
      const url = rawUrl ? new URL(String(rawUrl), location.href) : new URL(location.href);
      return /(?:^|\/)(?:watch|episode|episodes|stream|streaming|video|videos|play|player|embed)(?:\/|$|[-_?])/i.test(url.pathname + url.search);
    } catch (_) { return false; }
  }
  function smartPlayerStrongEvidence() {
    try {
      const scopedPlayerContext = smartPlayerRoute() || window.top !== window;
      if (scopedPlayerContext && document.querySelector('.video-js,.jwplayer,.plyr,.dplayer,.art-video-player,.clappr-container,.shaka-video-container,[data-shaka-player-container]')) {
        return 'known-player-root';
      }
      if (window.top !== window && document.querySelector([
        'script[src*="video.js"]', 'script[src*="video.min.js"]', 'script[src*="jwplayer"]',
        'script[src*="hls.js"]', 'script[src*="shaka-player"]', 'script[src*="dash.all"]',
        'script[src*="clappr"]', 'script[src*="plyr"]',
      ].join(','))) return 'known-player-root';
      // A nested embed frame is a player context in its own right, even when its
      // URL does not look like a watch/embed route -- intermediate embed hosts
      // often use opaque paths. Being a subframe is already the scoping signal.
      if (scopedPlayerContext) {
        if (document.querySelector('video')) return 'route-video';
        if (document.querySelector([
          'iframe[allowfullscreen]', 'iframe[allow*="autoplay"]', 'iframe[allow*="fullscreen"]',
          'iframe[allow*="picture-in-picture"]', 'iframe[allow*="encrypted-media"]',
        ].join(','))) return 'media-embed';
      }
    } catch (_) {}
    return '';
  }
  // Blocked scripts may have been required to build every player signal.
  // Report timed absence only when the worker independently saw a blocked script;
  // a page cannot turn this report into an allowlist decision.
  const SMART_PLAYER_DEADLOCK_MS = 4000;
  const SMART_PLAYER_LATE_SCAN_MS = 1500;
  let smartPlayerDeadlockDue = false;
  let smartPlayerSettled = false;
  let smartPlayerLateScanAt = 0;
  function smartPlayerDeadlock() {
    if (!smartPlayerDeadlockDue) return '';
    // A watch-shaped route, or a subframe, which is a player context in its own right.
    if (smartPlayerRoute() || window.top !== window) return 'route-blocked';
    // An ordinary top-level page that painted nothing is the OTHER shape this happens in, and it
    // used to get no recovery at all -- the scoping here said such a page "gains nothing", which
    // was true when the only thing recovery could rescue was a player. A site whose own
    // application code sits on a separate registrable domain has it refused as third-party and
    // then never paints, which is H13, M35, and a black page reported from live use.
    //
    // It earns a look, not an allowance. Nothing here decides anything: background acts only where
    // webRequest independently observed a blocked third-party script in this exact frame, which no
    // page can manufacture, and recovery still refuses hosts known for tracking or fingerprinting.
    // Blankness alone, on a page that blocked nothing, does nothing at all. Once an ordinary
    // top-level page has rendered normally, switch the mutation-driven scans into a throttled,
    // element-only follow-up mode. Text-changing controls no longer reach it, while a late player
    // root or an application shell that becomes blank can still be noticed before final teardown.
    if (smartPageIsBlank()) return 'page-blocked';
    setSmartPlayerQuietWatch();
    return '';
  }
  function sendSmartPlayerContext(force) {
    const now = Date.now();
    const evidence = smartPlayerStrongEvidence() || smartPlayerDeadlock();
    if (!evidence) return false;
    smartPlayerEvidence = evidence;
    cancelSmartPlayerScan();
    if (!force && now - smartPlayerLastSignalAt < 45000) return true;
    if (!bridgeRateOk('smart-player-context', 4, 120000)) return true;
    smartPlayerLastSignalAt = now;
    try { chrome.runtime.sendMessage({ kind: 'smart-player-context', evidence }, () => { void chrome.runtime.lastError; }); } catch (_) {}
    if (smartPlayerUnwatch) {
      smartPlayerUnwatch();
      smartPlayerUnwatch = null;
    }
    if (!smartPlayerHeartbeat) {
      // Bounded on purpose. bridge.js runs in EVERY frame, so an unbounded beat
      // meant one permanent wakeup per frame that ever saw a player, for the life
      // of the frame. That is the same cost the Browser Abuse Guard was removed to
      // avoid. Stop once the evidence is gone, once the context is established
      // long enough to be acted on, or as soon as the frame goes away.
      let beats = 0;
      smartPlayerHeartbeat = woInterval(() => {
        if (!smartPlayerEvidence || ++beats > SMART_PLAYER_HEARTBEAT_MAX) {
          stopSmartPlayerHeartbeat();
          return;
        }
        sendSmartPlayerContext(true);
      }, 60000);
    }
    return true;
  }
  function cancelSmartPlayerScan() {
    if (!smartPlayerScanTimer) return;
    try { clearTimeout(smartPlayerScanTimer); } catch (_) {}
    try { woPending.delete(smartPlayerScanTimer); } catch (_) {}
    smartPlayerScanTimer = null;
  }
  function smartPlayerMutationMayMatter(records) {
    for (const record of records || []) {
      let addedText = false;
      let removedText = false;
      let addedChars = 0;
      let removedChars = 0;
      for (const node of (record && record.addedNodes) || []) {
        if (node && node.nodeType === 1) return true;
        if (node && node.nodeType === 3) {
          const value = String(node.nodeValue || '');
          if (/\S/.test(value)) {
            addedText = true;
            addedChars += Math.min(value.length, 1000);
          }
        }
      }
      for (const node of (record && record.removedNodes) || []) {
        if (node && node.nodeType === 1) return true;
        if (node && node.nodeType === 3) {
          const value = String(node.nodeValue || '');
          if (/\S/.test(value)) {
            removedText = true;
            removedChars += Math.min(value.length, 1000);
          }
        }
      }
      if (removedText && !addedText) return true;
      if (removedChars > addedChars) return true;
    }
    return false;
  }
  function setSmartPlayerQuietWatch() {
    if (smartPlayerSettled) return;
    smartPlayerSettled = true;
    if (smartPlayerUnwatch) {
      smartPlayerUnwatch();
      smartPlayerUnwatch = null;
    }
    smartPlayerUnwatch = domWatch((records) => {
      if (!smartPlayerMutationMayMatter(records)) return;
      scheduleSmartPlayerScan(300, true);
    });
  }
  function scheduleSmartPlayerScan(delay, late) {
    if (smartPlayerEvidence || smartPlayerScanTimer || (!late && smartPlayerScanCount >= 48)) return;
    if (smartPlayerSettled && !late) return;
    let wait = Math.max(0, Number(delay) || 0);
    if (late) {
      const now = Date.now();
      const remaining = SMART_PLAYER_LATE_SCAN_MS - (now - smartPlayerLateScanAt);
      if (remaining > wait) wait = remaining;
    }
    smartPlayerScanTimer = woTimeout(() => {
      smartPlayerScanTimer = null;
      if (late) smartPlayerLateScanAt = Date.now();
      smartPlayerScanCount += 1;
      sendSmartPlayerContext(false);
    }, wait);
  }
  function armSmartPlayerObservation() {
    if (!bridgeRateOk('smart-player-rearm', 16, 60000)) return false;
    cancelSmartPlayerScan();
    smartPlayerEvidence = '';
    smartPlayerLastSignalAt = 0;
    smartPlayerScanCount = 0;
    smartPlayerSettled = false;
    smartPlayerLateScanAt = 0;
    scheduleSmartPlayerScan(0);
    if (smartPlayerUnwatch) {
      smartPlayerUnwatch();
      smartPlayerUnwatch = null;
    }
    const generation = ++smartPlayerObserverGeneration;
    smartPlayerUnwatch = domWatch(() => scheduleSmartPlayerScan(
      smartPlayerSettled ? 300 : 120, smartPlayerSettled), true);
    // The deadlock check has to drive itself. On the pages it exists for nothing else will call
    // sendSmartPlayerContext again -- there are no mutations to schedule a scan, because the
    // scripts that would cause them were blocked.
    smartPlayerDeadlockDue = false;
    woTimeout(() => {
      if (generation !== smartPlayerObserverGeneration) return;
      if (smartPlayerEvidence) return;
      smartPlayerDeadlockDue = true;
      sendSmartPlayerContext(true);
    }, SMART_PLAYER_DEADLOCK_MS);
    woTimeout(() => {
      // The generation check keeps a stale timer from inspecting or tearing down
      // a later re-arm. This final, mutation-independent check preserves recovery
      // for an application shell that painted at four seconds but failed later.
      if (generation !== smartPlayerObserverGeneration) return;
      cancelSmartPlayerScan();
      if (!smartPlayerEvidence) sendSmartPlayerContext(true);
      if (smartPlayerUnwatch) {
        smartPlayerUnwatch();
        smartPlayerUnwatch = null;
      }
      smartPlayerSettled = true;
    }, 20000);
    return true;
  }
  let smartPlayerTrustedIntentAt = 0;
  function smartPlayerIntentTarget(rawTarget) {
    try {
      const target = rawTarget && rawTarget.closest ? rawTarget : null;
      if (!target) return false;
      if (target.closest([
        'video', '.video-js', '.jwplayer', '.plyr', '.dplayer', '.art-video-player',
        '.clappr-container', '.shaka-video-container', '[data-shaka-player-container]',
        'iframe[allowfullscreen]', 'iframe[allow*="autoplay"]', 'iframe[allow*="fullscreen"]',
        'iframe[allow*="picture-in-picture"]', 'iframe[allow*="encrypted-media"]',
      ].join(','))) return true;
      // When the player UI is itself built by the third-party script Smart Script
      // Shield blocked, none of the checks above can ever match: no <video>, no
      // player root, and no labelled control is ever created. The recovery gesture
      // then becomes unreachable and the page sits on a dead spinner forever --
      // clicking the player is also invisible here, because a click inside a
      // cross-origin embed never reaches this document. Once this frame has
      // produced strong player evidence, treat any trusted click in it as player
      // intent. A page can fake the evidence DOM, but it cannot fake a trusted
      // user gesture, and that gesture is the property the recovery gate relies on.
      if (smartPlayerEvidence && (window.top !== window || smartPlayerRoute())) return true;
      if (!smartPlayerRoute()) return false;
      const control = target.closest('button,[role="button"],[data-episode],[data-server],a[href]');
      if (!control) return false;
      const label = String(control.textContent || control.getAttribute('aria-label')
        || control.getAttribute('title') || control.getAttribute('data-episode')
        || control.getAttribute('data-server') || '').slice(0, 160);
      return /(?:play|watch|server|episode|stream)/i.test(label);
    } catch (_) {
      return false;
    }
  }
  function sendSmartPlayerIntent() {
    if (!bridgeRateOk('smart-player-intent', 12, 60000)) return false;
    try { chrome.runtime.sendMessage({ kind: 'smart-player-intent' }, () => { void chrome.runtime.lastError; }); } catch (_) { return false; }
    return true;
  }
  function noteSmartPlayerIntent(event) {
    if (!event || event.isTrusted !== true) return;
    if (event.type === 'keydown' && !/^(?:Enter| |Spacebar|k|K|MediaPlayPause)$/.test(String(event.key || ''))) return;
    const target = event.type === 'keydown' && document.activeElement ? document.activeElement : event.target;
    if (!smartPlayerIntentTarget(target)) return;
    const now = Date.now();
    if (now - smartPlayerTrustedIntentAt < 400) return;
    smartPlayerTrustedIntentAt = now;
    sendSmartPlayerIntent();
  }
  try {
    // Not { once: true }: a page restored from the back/forward cache fires pagehide AGAIN, and a
    // one-shot listener has already been spent by then -- so a heartbeat started after the restore
    // ran until the tab closed. stopSmartPlayerHeartbeat is idempotent, so firing it more than once
    // costs nothing.
    woOn(window, 'pagehide', stopSmartPlayerHeartbeat);
    armSmartPlayerObservation();
    woOn(document, 'DOMContentLoaded', () => scheduleSmartPlayerScan(0), { once: true });
    woOn(window, 'load', () => scheduleSmartPlayerScan(0), { once: true });
    woOn(window, 'popstate', () => armSmartPlayerObservation());
    woOn(window, 'hashchange', () => armSmartPlayerObservation());
    woOn(document, 'pointerdown', noteSmartPlayerIntent, true);
    woOn(document, 'click', noteSmartPlayerIntent, true);
    woOn(document, 'keydown', noteSmartPlayerIntent, true);
    woOn(document, 'click', (event) => {
      if (!event || event.isTrusted === false) return;
      const target = event.target && event.target.closest
        ? event.target.closest('a[href],button,[role="button"],[data-episode]')
        : null;
      if (!target) return;
      const href = target.href || '';
      const label = String(target.textContent || target.getAttribute('aria-label') || target.getAttribute('data-episode') || '').slice(0, 160);
      if (!smartPlayerRoute(href) && !/(?:watch|episode|stream|play|server)/i.test(label)) return;
      woTimeout(() => armSmartPlayerObservation(), 0);
    }, true);
    [30000, 90000, 180000].forEach((delay) => {
      woTimeout(() => {
        if (!smartPlayerEvidence && smartPlayerRoute()) armSmartPlayerObservation();
      }, delay);
    });
  } catch (_) {}

  // M36. When Smart Script Shield is the reason a page is broken, say so.
  //
  // Refusing third-party scripts is what the shield is for, and on nearly every page it is right
  // and invisible. When it is wrong the page simply fails -- a black player, a splash screen that
  // never advances -- and the only route out is to already suspect the extension, find the Script
  // Shield panel and trust the site by hand. Three separate findings had that shape and each was
  // diagnosed only because someone happened to test with the extension off.
  //
  // Two conditions, evaluated where each is knowable: the page decides whether it looks broken,
  // background decides whether we refused anything on this navigation. Neither alone is worth
  // showing -- a refusal happens on almost every page, and a slow page is not our doing.
  let smartScriptNoticeOverlay = null;
  let smartScriptNoticeShown = false;
  let smartScriptNoticeAsked = false;

  function smartScriptNoticeAllowed() {
    return bridgeConfigReady
      && bridgeConfig.enabled !== false
      && !bridgeSilentModeOn()
      && !bridgeHostAllowedByUser()
      && window.top === window;
  }

  // Why the page looks broken, or '' if it does not.
  //
  // These three are the shapes the known reports actually had, and they are deliberately narrow.
  // A detector broad enough to catch "one widget on an otherwise working page did not render"
  // would fire on working pages, and a notice that cries wolf is worse than the silence it
  // replaces -- people learn to dismiss it and then it is there for nothing.
  // "This page painted nothing." One definition, two callers with different patience: the recovery
  // signal above asks at four seconds and needs only this, while the notice below waits until the
  // page has had every chance and also counts a page that never finished loading. Two separate
  // notions of blank would drift into disagreeing about the same page.
  function smartPageIsBlank() {
    try {
      if (document.prerendering) return false;
      // A canvas or a video IS the content on plenty of pages, and neither carries text.
      if (document.querySelector('video,canvas')) return false;
      const text = String((document.body && document.body.innerText) || '').replace(/\s+/g, ' ').trim();
      return text.length <= 200;
    } catch (_) {
      return false;
    }
  }

  function smartScriptPageStalled() {
    try {
      if (document.prerendering) return '';
      if (document.readyState !== 'complete') return 'the page never finished loading';
      // A watch or embed route that painted no player: loaded, but the one thing it exists to
      // show is missing.
      if (smartPlayerRoute() && !document.querySelector('video')) return 'the player never appeared';
      return smartPageIsBlank() ? 'nothing rendered' : '';
    } catch (_) {
      return '';
    }
  }

  function showSmartScriptNotice(info, reason) {
    if (smartScriptNoticeShown) return;
    smartScriptNoticeShown = true;
    let ring = null;
    try {
      /* Owned, not described. A page that has just had its scripts refused is not a trustworthy
         host for the explanation, and the button below changes a setting -- so it lives in a
         closed shadow root the page cannot read, reach into or dispatch on. */
      if (smartScriptNoticeOverlay) { try { smartScriptNoticeOverlay.destroy(); } catch (_) {} }
      smartScriptNoticeOverlay = woOwnedOverlay('wo-script-shield-notice');
      const root = smartScriptNoticeOverlay.root();
      if (!root) return;
      const panel = document.createElement('div');
      /* A status region, not a dialog. It does not cover the page and does not demand an answer,
         so it announces politely and never takes focus (M20). */
      panel.setAttribute('role', 'status');
      panel.setAttribute('style', 'all:initial!important;position:fixed!important;left:16px!important;'
        + 'bottom:16px!important;box-sizing:border-box!important;display:flex!important;'
        + 'flex-direction:column!important;gap:9px!important;max-width:380px!important;'
        + 'width:calc(100vw - 32px)!important;border:1px solid rgba(176,106,212,.34)!important;'
        + 'border-left:4px solid #9d54c9!important;border-radius:14px!important;'
        + 'background:linear-gradient(135deg,#faf2fe,#f4e9fb)!important;color:#3d2a52!important;'
        + 'padding:16px!important;box-shadow:0 18px 60px rgba(120,55,160,.3)!important;'
        + 'font-family:Nunito,system-ui,sans-serif!important;');
      const title = document.createElement('div');
      title.setAttribute('style', WO_MODAL.title);
      title.textContent = 'This page may be broken by WardenOne';
      const body = document.createElement('div');
      body.setAttribute('style', WO_MODAL.body);
      const count = Number(info && info.refused) || 0;
      body.textContent = 'Smart Script Shield blocked ' + count + ' third-party '
        + (count === 1 ? 'script' : 'scripts') + ' here, and ' + reason
        + '. That is usually right. If this site needs them, you can allow them and reload.';
      const meta = document.createElement('div');
      meta.setAttribute('style', WO_MODAL.meta);
      const hosts = Array.isArray(info && info.hosts) ? info.hosts.slice(0, 3) : [];
      meta.textContent = 'Blocked: ' + (hosts.length ? hosts.join(', ') : 'third-party scripts')
        + (count > hosts.length ? ' and ' + (count - hosts.length) + ' more' : '');
      const actions = document.createElement('div');
      actions.setAttribute('style', WO_MODAL.actions('flex-start'));
      const mkBtn = (label, primary) => {
        const btn = document.createElement('button');
        btn.setAttribute('style', WO_MODAL.button(primary, '12px'));
        btn.textContent = label;
        return btn;
      };
      const trust = mkBtn('Allow scripts here', true);
      let trustInFlight = false;
      /* Bound to this exact node. There is no selector to match and no element to forge: a page
         cannot obtain a reference to a node in a closed shadow root, so it cannot dispatch on it
         either. Background refuses the change unless it genuinely refused a script on this tab's
         current navigation, and reads the host from the sender rather than the message. */
      woOn(trust, 'click', (e) => {
        if (trustInFlight || !e || e.isTrusted === false) return;
        if (!smartScriptNoticeOverlay || !smartScriptNoticeOverlay.owns(trust)) return;
        trustInFlight = true;
        try { trust.disabled = true; trust.textContent = 'Allowing...'; } catch (_) {}
        try {
          chrome.runtime.sendMessage({ kind: 'smart-script-trust-site' }, (res) => {
            void chrome.runtime.lastError;
            if (chrome.runtime.lastError || !res || res.ok === false) {
              trustInFlight = false;
              try { trust.disabled = false; trust.textContent = 'Allow scripts here'; } catch (_) {}
              return;
            }
            try { location.reload(); } catch (_) {}
          });
        } catch (_) {
          trustInFlight = false;
        }
      });
      const dismiss = mkBtn('Dismiss', false);
      woOn(dismiss, 'click', (e) => {
        if (e && e.isTrusted === false) return;
        if (ring) { try { ring.release(); } catch (_) {} ring = null; }
        try { smartScriptNoticeOverlay.destroy(); } catch (_) {}
        smartScriptNoticeOverlay = null;
      });
      actions.appendChild(trust);
      actions.appendChild(dismiss);
      panel.appendChild(title);
      panel.appendChild(body);
      panel.appendChild(meta);
      panel.appendChild(actions);
      root.appendChild(panel);
      smartScriptNoticeOverlay.mount();
      /* No dialog() and no focus trap -- but the buttons still need a visible ring, and
         all:initial strips the one the browser would have drawn. Bound on the shadow root, where
         the focus events still name the button they came from. */
      ring = woFocusRing(root);
    } catch (_) {}
  }

  function checkSmartScriptNotice() {
    if (smartScriptNoticeAsked || smartScriptNoticeShown) return;
    if (!smartScriptNoticeAllowed()) return;
    const reason = smartScriptPageStalled();
    if (!reason) return;
    // Asked at most once per navigation, and only from here -- the page having already failed its
    // own check is what earns the question.
    smartScriptNoticeAsked = true;
    if (!bridgeRateOk('smart-script-status', 2, 60000)) return;
    try {
      chrome.runtime.sendMessage({ kind: 'smart-script-status' }, (res) => {
        void chrome.runtime.lastError;
        if (chrome.runtime.lastError || !res || !res.ok || !Number(res.refused)) return;
        showSmartScriptNotice(res, reason);
      });
    } catch (_) {}
  }

  try {
    // Two chances, both bounded. Five seconds after load is late enough that a merely slow page
    // has settled; the twenty-second timer is for the pages where load never fires at all, which
    // is one of the failure shapes this exists to catch.
    woOn(window, 'load', () => woTimeout(checkSmartScriptNotice, 5000), { once: true });
    woTimeout(checkSmartScriptNotice, 20000);
  } catch (_) {}

  function setLearnedGrabberDomains(learned) {
    try {
      // Both stages happen here now, at the storage boundary, so the merge in
      // sendConfig can trust the result instead of redoing the second one on every
      // page load in every frame.
      //
      // The order is load-bearing and matches what the two places used to do between
      // them. The bare-hostname regex runs FIRST and is the stricter of the two: it
      // rejects anything carrying a scheme, port or edge dots, which the shared gate
      // would otherwise happily parse a blockable hostname out of. Sanitising first
      // would turn a malformed learned key like "https://sub.example.co.uk/p" into a
      // live auto-block rather than discarding it -- blocking more than before, which
      // is the direction that breaks working sites.
      learnedGrabberDomains = sanitizeBridgeHostList(
        Object.keys(learned || {})
          .map((d) => String(d || '').replace(/^www\./, '').toLowerCase())
          .filter((d) => /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/i.test(d)),
        1000);
    } catch (_) {
      learnedGrabberDomains = [];
    }
  }

  function setSupplementalLists(raw) {
    const lists = raw && typeof raw === 'object' ? raw : {};
    supplementalLists = {
      adultDomainsExtra: sanitizeBridgeHostList(lists.adultDomainsExtra, 3000),
      grabberDomainsExtra: sanitizeBridgeHostList(lists.grabberDomainsExtra, 1500),
      trustedPaymentHostsExtra: sanitizeBridgeHostList(lists.trustedPaymentHostsExtra, 300),
    };
  }

  function mergeBridgeHostLists(limit, ...lists) {
    const out = [];
    const seen = new Set();
    const max = Math.max(1, Math.min(Number(limit) || 1000, 5000));
    for (const list of lists) {
      for (const item of (Array.isArray(list) ? list : [])) {
        if (out.length >= max) return out;
        const h = normalizeBridgeHost(item);
        if (!h || seen.has(h)) continue;
        seen.add(h);
        out.push(h);
      }
    }
    return out;
  }

  // Dedupe and cap, without re-normalising. Only safe for lists that already came out
  // of sanitizeBridgeHostList: normalizeBridgeHost is idempotent and that function's
  // output is a fixed point, so a second pass over it cannot change an entry -- it can
  // only cost time. Anything user- or remote-supplied must still go through
  // mergeBridgeHostLists.
  function mergeNormalizedHostLists(limit, ...lists) {
    const out = [];
    const seen = new Set();
    const max = Math.max(1, Math.min(Number(limit) || 1000, 5000));
    for (const list of lists) {
      for (const item of (Array.isArray(list) ? list : [])) {
        if (out.length >= max) return out;
        if (!item || seen.has(item)) continue;
        seen.add(item);
        out.push(item);
      }
    }
    return out;
  }

  function permissionChainGuardOn() {
    return bridgeConfigReady && bridgeConfig.enabled !== false && bridgeConfig.permissionChainGuard !== false && !bridgeHostAllowedByUser();
  }

  function scriptDriftGuardOn() {
    return bridgeConfigReady && bridgeConfig.enabled !== false && bridgeConfig.scriptDriftGuard !== false && !bridgeHostAllowedByUser();
  }

  function loginAgeGuardOn() {
    return bridgeConfigReady && bridgeConfig.enabled !== false && bridgeConfig.loginAgeCheck !== false && !bridgeHostAllowedByUser();
  }

  function bridgeSilentModeOn() {
    return bridgeConfigReady && bridgeConfig.silentMode === true;
  }

  // The page's copy of the two presentation switches under Silent mode: both off while it
  // is on, untouched otherwise. Writes only into the copy it is handed.
  function gateSilentPresentation(cfg, silent) {
    if (!cfg || typeof cfg !== 'object' || silent !== true) return cfg;
    cfg.showToasts = false;
    cfg.showBadge = false;
    return cfg;
  }

  function bridgeCleanHost(value) {
    return String(value || '').replace(/^www\./, '').replace(/^\.+|\.+$/g, '').toLowerCase();
  }

  function bridgeHostMatchesList(host, list) {
    const h = bridgeCleanHost(host);
    if (!h || !Array.isArray(list)) return false;
    return list.some((item) => hostMatchesSite(h, item));
  }

  // A host is allowlisted if it is on the permanent list, or if it holds a
  // temporary pass that has not lapsed yet. Expired entries simply stop counting;
  // pruning them from storage is the popup's job, not something to do on a hot
  // path in every frame.
  function bridgeActiveAllowlist(config) {
    const base = Array.isArray(config && config.allowlist) ? config.allowlist.slice(0, 1000) : [];
    const until = config && config.allowlistUntil;
    if (!until || typeof until !== 'object') return base;
    const now = Date.now();
    let added = 0;
    for (const host of Object.keys(until)) {
      if (added >= 200) break;
      const at = Number(until[host]);
      if (Number.isFinite(at) && at > now) { base.push(host); added++; }
    }
    return base;
  }

  // Which individual protections the user switched off for the page we are on.
  // Only ever turns something OFF: a site cannot enable a protection the user
  // disabled globally, so a stored true is ignored.
  function bridgeSiteOverridesFor(config, host) {
    const out = {};
    try {
      const rules = config && config.siteOverrides;
      if (!rules || typeof rules !== 'object') return out;
      const h = bridgeCleanHost(host);
      if (!h) return out;
      for (const pattern of Object.keys(rules)) {
        const d = bridgeCleanHost(pattern);
        if (!d || !hostMatchesSite(h, d)) continue;
        const entry = rules[pattern];
        if (!entry || typeof entry !== 'object') continue;
        for (const key of Object.keys(entry)) {
          if (entry[key] === false && /^[A-Za-z][A-Za-z0-9]{0,63}$/.test(key)) out[key] = false;
        }
      }
    } catch (_) {}
    return out;
  }

  function bridgeHostAllowedByUser() {
    return bridgeHostMatchesList(location.hostname, bridgeActiveAllowlist(bridgeConfig));
  }

  // ---- fingerprint noise in this frame (SEC-05) --------------------------------------------
  // The page's hosts, seen from any frame. ancestorOrigins lists every ancestor's origin, top
  // last, cross-origin ones included; an opaque ancestor reads "null". A window with no host in
  // its URL still has an origin worth reading: about:blank inherits its creator's, blob: carries
  // its creator's.
  function bridgeHostOfOrigin(origin) {
    try {
      const o = String(origin || '');
      if (!o || o === 'null') return '';
      return bridgeCleanHost(new URL(o).hostname);
    } catch (_) { return ''; }
  }
  function bridgeOwnHost() {
    let h = '';
    try { h = bridgeCleanHost(location.hostname); } catch (_) { h = ''; }
    if (h) return h;
    try { return bridgeHostOfOrigin(location.origin); } catch (_) { return ''; }
  }
  function bridgeTopHost() {
    try {
      if (window === window.top) return bridgeOwnHost();
      const list = location.ancestorOrigins;
      if (!list || !list.length) return '';
      return bridgeHostOfOrigin(list[list.length - 1]);
    } catch (_) { return ''; }
  }
  // Whether the anti-fingerprinting noise runs in this frame. fingerprint-realm.js runs the
  // engine's noise in the frames the engine never reaches, but it cannot read a switch off the
  // page and must not trust one a page posts, so the verdict is decided here -- where the
  // allowlist and the per-site switches are already resolved -- and travels inside the signed
  // config. Same decision the engine takes for the top frame (enabled, the switch or its alias,
  // not paused for the host), taken twice: once for this frame's own host and once for the
  // page's top host. "Pause on this site" and "noise off here" are choices about the page, and
  // an embedded frame is part of the page; a payment or captcha frame that broke under the noise
  // is fixed by the same pause that fixes the page around it. The per-site switches for this
  // frame's own host were already applied to `clean` above; the top host's are consulted here.
  function bridgeFrameNoiseAllowed(clean) {
    try {
      if (!clean || clean.enabled === false) return false;
      let noise = clean.antiFingerprintNoise === true;
      let alias = clean.antiFingerprint === true;
      if (!noise && !alias) return false;
      const own = bridgeOwnHost();
      if (own && bridgeHostMatchesList(own, clean.allowlist)) return false;
      const top = bridgeTopHost();
      if (top && top !== own) {
        if (bridgeHostMatchesList(top, clean.allowlist)) return false;
        const topOff = bridgeSiteOverridesFor(clean, top);
        if (topOff.antiFingerprintNoise === false) noise = false;
        if (topOff.antiFingerprint === false) alias = false;
      }
      return noise || alias;
    } catch (_) { return false; }
  }

  /* WebGL is a page-tree choice: a cross-origin game or viewer embedded by a selected site
     follows the top page, rather than escaping because its own frame has another hostname. */
  function bridgeFrameWebGLDisabled(clean) {
    try {
      if (!clean || clean.enabled === false) return false;
      const mode = /^(?:selected|everywhere)$/.test(String(clean.webglSaverMode || '')) ? String(clean.webglSaverMode) : 'off';
      const host = bridgeTopHost() || bridgeOwnHost();
      if (!host || mode === 'off') return false;
      if (bridgeHostMatchesList(host, clean.allowlist)) return false;
      if (mode === 'selected') return bridgeHostMatchesList(host, sanitizeBridgeHostList(clean.webglSaverBlockHosts, 300));
      return !bridgeHostMatchesList(host, sanitizeBridgeHostList(clean.webglSaverAllowHosts, 300));
    } catch (_) { return false; }
  }

  const SEARCH_AI_PREPAINT_CSS = [
    ':is(.MjjYud,div[data-hveid],div[jscontroller],div[jsname],g-section-with-header,section,aside):has(#m-x-content):not(:has(#rso,#search,#res,#center_col,.related-question-pair))',
    ':is(#m-x-content):not(:has(#rso,#search,#res,#center_col))',
    '#llm-answer,.llm-answer,[data-testid="llm-answer"],[data-testid="ai-answer"],[data-testid="answer-with-ai"]',
  ].join(',') + '{display:none!important;visibility:hidden!important;pointer-events:none!important;}' +
    ':is(html,#rso,#search,#res,#center_col) .related-question-pair #m-x-content{display:block!important;visibility:visible!important;pointer-events:auto!important;}';
  const SEARCH_SPONSORED_PREPAINT_CSS = [
    '#tads,#tadsb,#bottomads,#taw,#tvcap,.commercial-unit-desktop-top,.commercial-unit-desktop-rhs,.commercial-unit-mobile-top,.pla-unit,.uEierd,[data-text-ad],[data-pla],[data-google-query-id],div[aria-label="Ads"],div[aria-label="Sponsored"]',
    '[data-testid="ad"],[data-testid="ad-result"],[data-testid="sponsored-result"],.ad-result,.sponsored-result',
  ].join(',') + '{display:none!important;visibility:hidden!important;pointer-events:none!important;}' +
    ':is(html,#rso,#search,#res,#center_col) .related-question-pair :is(div[aria-label="Sponsored"],div[aria-label="Ads"]){display:block!important;visibility:visible!important;pointer-events:auto!important;}';

  function bridgeIsSearchResults() {
    try {
      return (/(^|\.)google\.[a-z.]+$/i.test(location.hostname) && /^\/(search|webhp)?$/i.test(location.pathname || '/'))
        || (location.hostname === 'search.brave.com' && /^\/search$/i.test(location.pathname || '/'));
    } catch (_) {
      return false;
    }
  }

  function bridgeSearchAiCleanupOn() {
    return bridgeConfigReady
      && bridgeConfig.enabled !== false
      && (bridgeConfig.blockSearchAiAnswers === true || bridgeConfig.googleSearchResultCleanup === true)
      && !bridgeHostAllowedByUser();
  }

  function bridgeSearchSponsoredCleanupOn() {
    return bridgeConfigReady
      && bridgeConfig.enabled !== false
      && (bridgeConfig.blockSponsoredSearchResults === true || bridgeConfig.googleSearchResultCleanup === true)
      && !bridgeHostAllowedByUser();
  }

  function bridgeSyncGoogleCleanupCss() {
    try {
      if (!bridgeIsSearchResults()) return;
      const syncOne = (id, on, css) => {
        const existing = document.getElementById(id);
        if (!on) {
          if (existing) existing.remove();
          return;
        }
        if (existing) return;
        const s = document.createElement('style');
        s.id = id;
        s.textContent = css;
        (document.head || document.documentElement).appendChild(s);
      };
      syncOne('wo-search-ai-cleanup-prepaint-css', bridgeSearchAiCleanupOn(), SEARCH_AI_PREPAINT_CSS);
      syncOne('wo-search-sponsored-cleanup-prepaint-css', bridgeSearchSponsoredCleanupOn(), SEARCH_SPONSORED_PREPAINT_CSS);
    } catch (_) {}
  }

  const SAFE_BROWSING_INTENT_TTL_MS = 8000;
  const safeBrowsingIntentUrls = [];
  let safeBrowsingTrustedAt = 0;
  function safeBrowsingCanonicalUrl(raw) {
    try {
      const u = new URL(String(raw || ''), location.href);
      if (u.protocol !== 'http:' && u.protocol !== 'https:') return '';
      u.hash = '';
      return u.href;
    } catch (_) {
      return '';
    }
  }
  function rememberSafeBrowsingIntent(raw) {
    const href = safeBrowsingCanonicalUrl(raw);
    if (!href) return;
    const now = Date.now();
    safeBrowsingIntentUrls.push({ href, at: now });
    while (safeBrowsingIntentUrls.length > 40) safeBrowsingIntentUrls.shift();
  }
  function rememberSafeBrowsingRedirectTargets(raw) {
    try {
      const href = safeBrowsingCanonicalUrl(raw);
      if (!href) return;
      const u = new URL(href);
      ['url', 'u', 'q', 'adurl', 'target', 'dest', 'destination', 'redirect', 'redirect_url', 'to'].forEach((key) => {
        const v = u.searchParams.get(key);
        if (/^https?:\/\//i.test(String(v || ''))) rememberSafeBrowsingIntent(v);
      });
    } catch (_) {}
  }
  function markTrustedSafeBrowsingEvent(e) {
    if (!e || e.isTrusted === false) return false;
    safeBrowsingTrustedAt = Date.now();
    return true;
  }
  function safeBrowsingFormAction(form) {
    try {
      return form && (form.getAttribute('action') || form.action) || location.href;
    } catch (_) {
      return location.href;
    }
  }
  function safeBrowsingIntentAllowed(rawUrl, context) {
    const href = safeBrowsingCanonicalUrl(rawUrl);
    if (!href) return false;
    const now = Date.now();
    for (let i = safeBrowsingIntentUrls.length - 1; i >= 0; i--) {
      if (now - safeBrowsingIntentUrls[i].at > SAFE_BROWSING_INTENT_TTL_MS) safeBrowsingIntentUrls.splice(i, 1);
    }
    const current = safeBrowsingCanonicalUrl(location.href);
    if (href === current) return true;
    if (safeBrowsingIntentUrls.some((item) => item.href === href)) return true;
    // Payment guards can use fetch/XHR after the click/input event that submitted
    // the checkout. There may be no DOM form action to bind to, so keep this short.
    return context === 'form' && now - safeBrowsingTrustedAt <= 2500;
  }
  try {
    woOn(document, 'click', (e) => {
      if (!markTrustedSafeBrowsingEvent(e)) return;
      const target = e.target;
      const link = target && target.closest ? target.closest('a[href],area[href]') : null;
      if (link) {
        rememberSafeBrowsingIntent(link.href || link.getAttribute('href'));
        rememberSafeBrowsingRedirectTargets(link.href || link.getAttribute('href'));
      }
      const form = target && target.closest ? target.closest('form') : null;
      if (form) rememberSafeBrowsingIntent(safeBrowsingFormAction(form));
    }, true);
    woOn(document, 'submit', (e) => {
      if (!markTrustedSafeBrowsingEvent(e)) return;
      rememberSafeBrowsingIntent(location.href);
      rememberSafeBrowsingIntent(safeBrowsingFormAction(e.target));
    }, true);
    woOn(document, 'paste', (e) => {
      if (!markTrustedSafeBrowsingEvent(e)) return;
      rememberSafeBrowsingIntent(location.href);
      const target = e.target;
      const form = target && target.closest ? target.closest('form') : null;
      if (form) rememberSafeBrowsingIntent(safeBrowsingFormAction(form));
    }, true);
    woOn(document, 'input', (e) => {
      const target = e && e.target;
      if (!markTrustedSafeBrowsingEvent(e) || !target) return;
      const hay = String((target.name || '') + ' ' + (target.id || '') + ' ' + (target.autocomplete || '') + ' ' + (target.placeholder || '')).toLowerCase();
      if (/cc-|card|credit|debit|cardnumber|ccnum|pan|cvc|cvv|security.?code/.test(hay)) {
        rememberSafeBrowsingIntent(location.href);
        const form = target.closest ? target.closest('form') : null;
        if (form) rememberSafeBrowsingIntent(safeBrowsingFormAction(form));
      }
    }, true);
  } catch (_) {}

  function mainWorldConfigForHost(source, host) {
    const clean = Object.assign({}, source || {});
    const current = normalizeBridgeHost(host);
    clean.allowlist = current && bridgeHostMatchesList(current, clean.allowlist) ? [current] : [];
    delete clean.forgetMeList;
    delete clean.allowlistUntil;
    delete clean.siteOverrides;
    delete clean.memoryNeverSleepHosts;
    delete clean.rebindQuarantine;
    for (const field of Object.keys(clean)) {
      if (/ByHost$|Key$/.test(field)) delete clean[field];
    }
    return clean;
  }

  const sendConfig = (overrides) => {
    const raw = (overrides && typeof overrides === 'object') ? overrides : {};
    bridgeConfig = Object.assign({}, bridgeConfig, raw);
    bridgeConfig.allowlist = sanitizeBridgeHostList(bridgeConfig.allowlist, 1000);
    bridgeConfig.forgetMeList = sanitizeBridgeHostList(bridgeConfig.forgetMeList, 1000);
    bridgeConfigReady = true;
    bridgeSyncGoogleCleanupCss();
    const clean = Object.assign({}, raw);
    // Provider API keys must never reach the MAIN world, where any page script can
    // read them. Strip by pattern rather than by name: a hand-written delete list
    // silently leaks the day someone adds an eighth provider. Anything ending in
    // "Key" is treated as a secret, and tools/test-secret-hygiene.js fails if a
    // secret-shaped field in DEFAULT_CONFIG is not covered here.
    for (const field of Object.keys(clean)) {
      if (/Key$/.test(field)) delete clean[field];
    }
    delete clean.forgetMeAllConfirmedAt;
    // Everything downstream reads clean.allowlist and never learns that a pass
    // was temporary, which is the point: one resolution, no second opinion.
    clean.allowlist = sanitizeBridgeHostList(bridgeActiveAllowlist(clean), 1000);
    delete clean.allowlistUntil;
    // Per-site switches are applied here rather than shipped as data, so no
    // downstream script has to remember to consult them.
    const siteOff = bridgeSiteOverridesFor(clean, location.hostname);
    for (const key of Object.keys(siteOff)) {
      if (typeof clean[key] === 'boolean') clean[key] = false;
      // The bridge's own gates (permission chain, script drift, login age, search cleanup) read
      // bridgeConfig, not the copy handed to the page; an override the page saw and the bridge
      // did not was half an exception (FEAT-01).
      if (typeof bridgeConfig[key] === 'boolean') bridgeConfig[key] = false;
    }
    clean.siteOverridesApplied = Object.keys(siteOff).filter((k) => typeof clean[k] === 'boolean');
    // Decided while siteOverrides is still here to consult for the top host (SEC-05). The engine
    // in the top frame ignores this field and decides for itself, as it always has.
    clean.frameNoise = bridgeFrameNoiseAllowed(clean);
    clean.webglDisabled = bridgeFrameWebGLDisabled(clean);
    delete clean.webglSaverMode;
    delete clean.webglSaverBlockHosts;
    delete clean.webglSaverAllowHosts;
    delete clean.siteOverrides;
    // Silent mode is a gate over presentation, not a rewrite of it. The engine reads
    // showToasts and showBadge and nothing else, so Silent has to reach it as those two
    // being off -- and this copy, the one the page gets, is where that happens, the same
    // way a per-site override reaches it just above. The stored preferences underneath are
    // never touched: the popup used to write them false while Silent was on and read the
    // disabled switches back on the way out, so turning Silent off left both off until the
    // reader found and re-enabled two separate switches. Whichever surface set silentMode
    // (the popup's toggle or the onboarding choice), the page sees the same thing, and
    // Normal gets back exactly what was chosen before. Read from the merged view, so a
    // partial update while Silent is on cannot let a switch back through.
    gateSilentPresentation(clean, bridgeConfig.silentMode === true);
    clean.forgetMeList = sanitizeBridgeHostList(clean.forgetMeList, 1000);
    // The stored `raw.*Extra` lists are user/remote supplied and still need the full
    // gate. learnedGrabberDomains and supplementalLists.* already came out of it at the
    // storage boundary, so they are merged by identity -- re-normalising them was the
    // bulk of the per-frame cost, paid again on every page load in every frame.
    const grabberExtras = mergeNormalizedHostLists(1500,
      sanitizeBridgeHostList(raw.grabberDomainsExtra, 1500),
      learnedGrabberDomains,
      supplementalLists.grabberDomainsExtra);
    if (grabberExtras.length) clean.grabberDomainsExtra = grabberExtras;
    else delete clean.grabberDomainsExtra;
    const adultExtras = mergeNormalizedHostLists(3000,
      sanitizeBridgeHostList(raw.adultDomainsExtra, 3000),
      supplementalLists.adultDomainsExtra);
    if (adultExtras.length) clean.adultDomainsExtra = adultExtras;
    else delete clean.adultDomainsExtra;
    const paymentExtras = mergeNormalizedHostLists(300,
      sanitizeBridgeHostList(raw.trustedPaymentHostsExtra, 300),
      supplementalLists.trustedPaymentHostsExtra);
    if (paymentExtras.length) clean.trustedPaymentHostsExtra = paymentExtras;
    else delete clean.trustedPaymentHostsExtra;
    // This frame's own site, from the bridge's own state only: an options-page config-update
    // carries no site, and a value that arrived inside overrides would be a second opinion on
    // who this frame is. Inside the signed copy, so the page cannot supply one either (SEC-07).
    clean.frameSite = bridgeFrameSite;
    const pageConfig = mainWorldConfigForHost(clean, location.hostname);
    postToPage(signed('config', JSON.stringify(pageConfig), { source: 'wardenone', kind: 'config', token: TOKEN, overrides: pageConfig }));
    try { document.dispatchEvent(new CustomEvent('wo-bridge-config-ready')); } catch (_) {}
  };
  const bridgeReplay = () => {
    // The key goes out again only while nothing but content scripts can be listening; a
    // detector registered after this bridge asks at its own document_start and gets it, a page
    // asking later gets the nonce and the config it has already seen.
    deliverKey();
    postToPage({ source: 'wardenone-handshake', token: TOKEN });
    if (bridgeConfigReady) sendConfig(bridgeConfig);
  };
  try {
    window.__wardenOneBridgeReplay = bridgeReplay;
  } catch (_) {}

  // The same replay, reachable from the MAIN world.
  //
  // `window` is not shared: this file runs in ISOLATED, so the global above is on a window the
  // main world can never see. cryptominer-detect.js runs in MAIN and asked for a replay through
  // it, which meant its `typeof ... === 'function'` test was false every single time and the
  // request silently did nothing -- so a detector injected after the one-time handshake never got
  // a token, rejected the config that followed, and sat on confirmed detections forever.
  //
  // `document` IS shared, and is already how the main world talks to this one. A page can dispatch
  // this too, and gains nothing by it: a replay re-sends the same handshake and the same sanitized
  // config the page has already been posted. It is rate-limited so it cannot be used to spam.
  //
  // Every MAIN consumer (the engine, anti-redirect, permission-chain, the miner detector, the
  // Spotify module) asks once at its own start, in case this bridge ran before it; the budget
  // has to cover all of them in the same second and still leave a page nothing worth spamming.
  woOn(document, 'wo-bridge-replay', () => {
    if (!bridgeRateOk('wo-bridge-replay', 12, 60000)) return;
    try { bridgeReplay(); } catch (_) {}
  });

  // 1. Listen for the custom events the main-world trap dispatches on document,
  //    and forward block/detection counts to the background for the toolbar badge.
  /* ---- engine watchdog -------------------------------------------------------------
     The MAIN-world engine shares its world with the page, so a page can call its dispose
     and switch it off. That is a known limit of MAIN-world injection and cannot be
     prevented from inside that world -- the page owns it. The engine already answers it
     halfway: disposing clears its own ready markers, so the tab stops claiming to be
     protected and a fresh injection can take hold. The comment there says the point is
     that "the bypass has to be repeated rather than done once and left".
     It was not, though, because nothing ever re-injected. One call at document_start
     switched the engine off for the life of the page and no one found out.
     This half closes that. It runs in the ISOLATED world, which the page cannot reach or
     read, so a page can silence the engine but cannot silence the thing that notices. If
     the engine never announced itself, or announced itself and then went quiet, the worker
     is asked to look and put it back.
     A page can still spoof the marker to look installed. That is a much higher bar than
     one call, and it is the honest limit of what this can do. */
  /* The engine has to PROVE it is there. "installed" counts only when it carries the key's
     signature, and a live engine is one that answers a challenge with the key: the bridge
     dispatches wo-ping with a fresh nonce and the engine, still inside that dispatch, emits a
     signed pong. A page can dispatch wo-event all day; it cannot sign. So a disposed engine
     with its markers put back looks, from here, exactly like no engine at all -- which is what
     it is. The worker is told what this bridge saw and whether it was here at document_start,
     and it reloads the tab rather than injecting into a document the page has already had. */
  let bridgeEngineSeen = false;
  let bridgeEngineChecks = 0;
  let bridgePendingPong = null;
  const engineAnswers = () => {
    if (!KEY) return false;
    let nonce = '';
    try { const b = new Uint8Array(16); crypto.getRandomValues(b); for (let i = 0; i < b.length; i++) nonce += (b[i] < 16 ? '0' : '') + b[i].toString(16); } catch (_) { return false; }
    let answered = false;
    bridgePendingPong = { nonce, ok: () => { answered = true; } };
    try { document.dispatchEvent(new CustomEvent('wo-ping', { detail: { nonce } })); } catch (_) {}
    bridgePendingPong = null;
    return answered;
  };
  const bridgeCheckEngine = (why) => {
    if (bridgeEngineChecks++ > 4) return;   // never a loop, whatever the page does
    try {
      chrome.runtime.sendMessage({ kind: 'wo-engine-check', why: String(why || '').slice(0, 40), fresh: BRIDGE_FRESH, seen: bridgeEngineSeen },
        () => { void chrome.runtime.lastError; });
    } catch (_) { /* worker asleep; the next trigger will try again */ }
  };
  const bridgeVerifyEngine = (whenAbsent) => {
    if (!bridgeEngineSeen) { bridgeCheckEngine(whenAbsent); return; }
    if (!engineAnswers()) bridgeCheckEngine('disposed');
  };
  try {
    if (window.top === window && /^https?:$/.test(location.protocol)) {
      /* Long enough that a slow page has finished installing, short enough to matter. */
      woTimeout(() => { bridgeVerifyEngine('never-announced'); }, 6000);
      /* Coming back to a tab is a free moment to re-check, and it is when a page that
         switched the engine off after load would otherwise keep the benefit. */
      woOn(document, 'visibilitychange', () => {
        if (document.visibilityState === 'visible') bridgeVerifyEngine('still-absent');
      });
      /* And while the tab stays in front, a challenge now and then; a healthy engine answers
         for free, and only a failed answer costs a message. */
      woInterval(() => { if (document.visibilityState === 'visible' && bridgeEngineSeen) bridgeVerifyEngine('still-absent'); }, 45000);
    }
  } catch (_) {}

  /* The redirect interstitial is the one thing a wo-event makes the worker DO -- navigate the
     tab to WardenOne's own warning page with a Continue button pointing at the event's url --
     and the token that routes these events is public. A page that dispatched
     blocked_gestureless_nav with a url of its own and silent:false put its landing page behind a
     genuine, WardenOne-branded Continue on a real chrome-extension:// page, and could raise it
     eight times a minute to devalue the warning a real hijack raises (SEC-15). The guard now
     signs an interstitial request under the key this bridge handed out at document_start, over
     a number that only moves forward and the destination, the reason and the kind the page will
     show (the SEC-13 scheme); nothing that fails the signature, repeats a number or was altered
     in flight is relayed. The badge count for the same event is unchanged: a block is a number,
     not an action. */
  let interstitialSeqSeen = 0;
  const interstitialRequestSigned = (detail) => {
    const seq = Number(detail && detail.seq);
    if (!KEY || !Number.isInteger(seq) || seq <= interstitialSeqSeen) return false;
    if (!__woAuth.same(detail.mac, engineMac('redirect-warning', seq + '\n' + String(detail.url) + '\n' + String(detail.why || '') + '\n' + String(detail.kind || '')))) return false;
    interstitialSeqSeen = seq;
    return true;
  };

  /* Capture at window before a page's document listener can stop propagation of a warning.
     MAIN dispatches on document; a non-bubbling event still travels down the capture path. */
  woOn(window, 'wo-event', (e) => {
    const d = (e && e.detail) || {};
    // Route only token-bearing events. The token is not treated as a true secret;
    // background learning and privileged actions are separately constrained.
    if (d.token !== TOKEN) return;
    const type = d.type || '';
    if (type === 'installed') {
      if (__woAuth.same(d.mac, engineMac('installed', TOKEN))) bridgeEngineSeen = true;
      return;
    }
    if (type === 'pong') {
      if (bridgePendingPong && d.nonce === bridgePendingPong.nonce && __woAuth.same(d.mac, engineMac('pong', bridgePendingPong.nonce))) bridgePendingPong.ok();
      return;
    }
    if (type === 'warning_panel') {
      if (d.src === 'engine' && eventSigned(d)) showOwnedMainWarning(d.detail);
      return;
    }
    if (type === 'warning_toast') {
      if (d.src === 'engine' && eventSigned(d)) showOwnedMainToast(d.detail);
      return;
    }
    const securitySignal = type === 'behavioral_risk'
      || /^warned_(?:potential_)?xss_|^warned_potential_(?:dom_xss|xss_)|^warned_clickfix_|^warned_command_paste$/.test(type);
    /* Routine page actions the Activity log never takes -- cleaned addresses and copied links,
       stripped pings, cookie banners rejected, search clutter hidden, script cookie writes
       stopped. They go to the Site Dashboard's count only (rg-tally): no log entry, no badge.
       Signed like a finding, so a page cannot inflate them. */
    if (/^(?:cleaned_history_url|stripped_link_ping|cleaned_copied_link|consent_rejected|google_search_cleanup|scriptlet_mutator_blocked|youtube_ads_removed)$/.test(type)) {
      if (!eventSigned(d) || d.src === 'bridge') return;
      if (window !== window.top || !bridgeRateOk('wo-tally', 240, 60000)) return;
      const hidden = Number(d.detail && d.detail.hidden);
      const count = Number(d.detail && d.detail.count);
      const n = type === 'google_search_cleanup' && hidden > 0 ? Math.min(200, Math.floor(hidden))
        : type === 'youtube_ads_removed' && count > 0 ? Math.min(20, Math.floor(count)) : 1;
      let pageStart = 0;
      try { pageStart = Math.round(performance.timeOrigin); } catch (_) {}
      try {
        chrome.runtime.sendMessage({ kind: 'rg-tally', type, n, pageStart }, () => { void chrome.runtime.lastError; });
      } catch (_) {}
      return;
    }
    if (/^blocked_|^detected_|^gated_|^warned_/.test(type) || type === 'behavioral_risk') {
      /* Only a signed event is a finding (see eventSigned). The bridge's own notices are for the
         page's notice card and are not findings to record. */
      if (!eventSigned(d) || d.src === 'bridge') return;
      if (!bridgeRateOk(securitySignal ? 'wo-security-event' : 'wo-event', securitySignal ? 12 : 240, 60000)) return;
      try {
        chrome.runtime.sendMessage({ kind: 'rg-block', type, detail: boundedBridgeDetail(d.detail) }, () => { void chrome.runtime.lastError; });
      } catch (_) {
        // background may be asleep; it's fine, the badge is best-effort
      }
      // silent === true means the hardener kept the user on their page (forced
      // redirect / popunder / overlay click) — no interstitial, just the badge.
      if (type === 'blocked_gestureless_nav' && d.detail && d.detail.url && d.detail.why !== 'no recent user gesture' && d.detail.silent !== true) {
        // And only the guard may ask for one (SEC-15); the badge above already has the block.
        if (!interstitialRequestSigned(d.detail)) return;
        try {
          chrome.runtime.sendMessage({ kind: 'redirect-warning', detail: boundedBridgeDetail(d.detail) }, () => { void chrome.runtime.lastError; });
        } catch (_) {}
      }
    }
  }, true);

  // Navigation attribution signals. Deliberately NOT routed through the wo-event
  // path above: they are not findings, must never reach the history or the badge,
  // and are far too frequent for the security-event budget.
  //
  // And they are signed (SEC-13). Two of them -- 'gesture' and 'top-nav-authorized' -- tell
  // the worker that a cross-site navigation was the reader's doing, which switches the
  // forced-redirect interstitial off for that tab; a page holding only the public token used
  // to be able to say that itself, every two seconds, for as long as it liked. A beacon now
  // counts only when its HMAC under the key this bridge handed out at document_start
  // verifies over a sequence number that has moved forward, the kind, and -- for an
  // authorisation -- the host it is for. The page still sees every one of these events and
  // can dispatch them; it cannot sign one, and it cannot replay one.
  let navSignalSeqSeen = 0;
  woOn(document, 'wo-nav-signal', (e) => {
    const d = (e && e.detail) || {};
    if (d.token !== TOKEN) return;
    const kind = d.kind === 'player-gesture' || d.kind === 'popup-overlay' || d.kind === 'top-nav-authorized' || d.kind === 'gesture'
      ? d.kind : '';
    if (!kind) return;
    const host = kind === 'top-nav-authorized' ? String(d.host || '').toLowerCase() : '';
    if (kind === 'top-nav-authorized' && !/^[a-z0-9.-]{1,253}$/.test(host)) return;
    const seq = Number(d.seq);
    if (!Number.isInteger(seq) || seq <= navSignalSeqSeen) return;
    if (!KEY || !__woAuth.same(d.mac, engineMac('nav-signal', seq + '\n' + kind + '\n' + host))) return;
    navSignalSeqSeen = seq;
    if (!bridgeRateOk('wo-nav-signal', 180, 60000)) return;
    try {
      chrome.runtime.sendMessage({ kind: 'wo-nav-signal', signal: kind, host }, () => { void chrome.runtime.lastError; });
    } catch (_) {}
  });

  // Content scripts cannot read storage.local: worker snapshots omit credentials.
  // Retry failed or malformed MV3 replies with bounded backoff, and apply only
  // newer revisions so a late response cannot roll back settings.
  const CONTENT_CONFIG_NEED = ['overrides', 'learned', 'supplemental', 'hidden'];
  const CONFIG_RETRY_BASE_MS = 300;
  const CONFIG_RETRY_MAX_MS = 5000;
  const CONFIG_RETRY_ATTEMPTS = 8;
  // The last snapshot applied here, and its revision. `rev` is the worker's build time for
  // the shared snapshot: a newer configuration is a newer build.
  let bridgeSnapshot = null;
  let bridgeConfigRev = 0;
  // A retrying request: `cb(res)` once with a usable answer, or `cb(null)` once the budget is
  // spent or `stop()` says the answer is no longer needed. By default failures retry at 300 ms
  // doubling to 5 s, eight attempts (~30 s), so a worker that is briefly gone is asked again
  // while a worker that is really gone is not asked forever.
  const bridgeAskUntilAnswered = (message, usable, cb, options) => {
    const o = options || {};
    const maxAttempts = Number(o.attempts) > 0 ? Number(o.attempts) : CONFIG_RETRY_ATTEMPTS;
    const baseMs = Number(o.baseMs) > 0 ? Number(o.baseMs) : CONFIG_RETRY_BASE_MS;
    const maxMs = Number(o.maxMs) > 0 ? Number(o.maxMs) : CONFIG_RETRY_MAX_MS;
    const deadlineMs = Number(o.deadlineMs) > 0 ? Number(o.deadlineMs) : 8000;
    const stop = typeof o.stop === 'function' ? o.stop : () => false;
    let attempts = 0;
    let settled = false;
    const finish = (res) => {
      if (settled) return;
      settled = true;
      try { cb(res); } catch (_) {}
    };
    const attempt = () => {
      if (settled) return;
      if (stop()) { finish(null); return; }
      attempts += 1;
      let called = false;
      // A reply that never comes at all is treated like a failed one: nothing in this
      // world can tell a dead worker from a slow one except waiting.
      const deadline = woTimeout(() => { if (!called) { called = true; retry(); } }, deadlineMs);
      const onReply = (res) => {
        if (called) return;
        called = true;
        clearTimeout(deadline);
        woPending.delete(deadline);
        const err = chrome.runtime.lastError;
        void err;
        if (err || !usable(res)) { retry(); return; }
        finish(res);
      };
      try {
        chrome.runtime.sendMessage(message, onReply);
      } catch (_) {
        if (!called) { called = true; clearTimeout(deadline); woPending.delete(deadline); retry(); }
      }
    };
    const retry = () => {
      if (settled) return;
      if (attempts >= maxAttempts || stop()) { finish(null); return; }
      const delay = Math.min(maxMs, baseMs * Math.pow(2, attempts - 1));
      woTimeout(attempt, delay);
    };
    attempt();
  };
  const bridgeFetchContentConfig = (need, cb, budget) => {
    const wanted = Array.isArray(need) && need.length ? need.slice(0, 8) : CONTENT_CONFIG_NEED.slice();
    const maxAttempts = Number(budget) > 0 ? Math.min(CONFIG_RETRY_ATTEMPTS, Number(budget)) : CONFIG_RETRY_ATTEMPTS;
    bridgeAskUntilAnswered({ kind: 'content-config-get', need: wanted }, (res) => !!(res && res.ok), cb,
      { attempts: maxAttempts });
  };
  // The full snapshot gathers several datasets and can arrive after a first player click, so the
  // worker is also asked for only the popup switches (storage stays private to trusted extension
  // contexts). Apart from the popup guards and the player-frame guards these switches cover, no
  // MAIN-world guard is enabled until the full content-config-get reply arrives -- and none of
  // them is enabled before an answer of either kind says what the reader chose.
  //
  // Asked until answered, like the full snapshot, but on a short budget: it matters only for the
  // moments before the full snapshot lands, so it stops as soon as that has. A cold worker -- the
  // first message of a new document is what wakes it -- used to answer this one request with
  // runtime.lastError, and a player frame stayed unguarded until the full snapshot arrived, which
  // on a slow wake was seconds. Retries at 150 ms doubling, five attempts, two seconds' wait per
  // attempt: well inside the worker's 500-a-minute allowance for this message.
  const BOOTSTRAP_RETRY = { attempts: 5, baseMs: 150, maxMs: 1200, deadlineMs: 2000, stop: () => bridgeConfigReady };
  const requestRedirectBootstrap = () => {
    bridgeAskUntilAnswered({ kind: 'redirect-bootstrap-get' }, (res) => !!(res && res.ok && res.overrides), (res) => {
      if (!res || bridgeConfigReady) return;
      const bootstrap = res.overrides;
      postToPage(signed('redirect-bootstrap', JSON.stringify(bootstrap), {
        source: 'wardenone', kind: 'redirect-bootstrap', token: TOKEN, overrides: bootstrap,
      }));
    }, BOOTSTRAP_RETRY);
  };
  // Apply an answer to this frame. A revision older than the one already applied is a late
  // reply from an earlier request -- the worker has since rebuilt its snapshot -- and is dropped;
  // the same revision is applied again harmlessly (a refresh that changed nothing).
  const applyContentSnapshot = (res) => {
    if (!res || !res.ok) return false;
    const rev = Number(res.rev) || 0;
    if (rev && bridgeConfigRev && rev < bridgeConfigRev) return false;
    if (rev) bridgeConfigRev = rev;
    bridgeSnapshot = res;
    setLearnedGrabberDomains(res.learned);
    setSupplementalLists(res.supplemental);
    if (Array.isArray(res.hidden) && res.hidden.length) bridgeApplyUserHidden(res.hidden);
    bridgeFrameSite = normalizeBridgeHost(res.site) || '';
    sendConfig(res.overrides || {});
    return true;
  };
  // Only one acquisition runs at a time; a new one (a refresh, a page shown again) supersedes
  // whatever an older one was still waiting for.
  let configAcquisition = 0;
  // Sibling requests that arrive while a refresh is on its way wait for it. Answering them from
  // the snapshot being replaced undid settings changes: on a change the worker tells every tab
  // to refresh, and Eye Shield -- told the same thing -- asked here while this bridge's own
  // re-fetch was still in flight, got the old snapshot, and put the old mode back. Nothing
  // told it again when the new snapshot landed, so an open tab kept the mode it had until the
  // reader pressed Save a second time.
  let acquisitionInFlight = false;
  const acquisitionWaiters = [];
  const releaseAcquisitionWaiters = () => {
    const waiting = acquisitionWaiters.splice(0, acquisitionWaiters.length);
    for (let i = 0; i < waiting.length; i++) { try { waiting[i](); } catch (_) {} }
  };
  const requestContentConfig = () => {
    const mine = ++configAcquisition;
    acquisitionInFlight = true;
    bridgeFetchContentConfig(CONTENT_CONFIG_NEED, (res) => {
      if (mine !== configAcquisition) return;
      acquisitionInFlight = false;
      applyContentSnapshot(res);
      releaseAcquisitionWaiters();
    });
  };
  requestRedirectBootstrap();
  requestContentConfig();
  // A document restored from the back/forward cache asks again -- the worker may have changed
  // while it slept and could not reach a frozen page -- and a document that was never answered
  // asks again when it becomes visible, in case its budget ran out while the worker was away.
  woOn(window, 'pageshow', (event) => {
    if ((event && event.persisted) || !bridgeConfigReady) requestContentConfig();
  });
  woOn(document, 'visibilitychange', () => {
    if (document.visibilityState === 'visible' && !bridgeConfigReady) requestContentConfig();
  });
  // For the other isolated scripts in this frame. `window` here is the isolated world's, which
  // the page can never see, so nothing crosses to MAIN through this. A caller that needs only
  // what this bridge already fetched is answered from the applied snapshot without a round
  // trip; any other need is a retrying request of its own, on a shorter budget (four attempts,
  // about five seconds): those scripts fall back to their defaults when unanswered, and a
  // default-on protection should not wait half a minute to start on a worker that is gone.
  const SIBLING_CONFIG_ATTEMPTS = 4;
  // How long a sibling waits on a refresh in flight before it is answered from what is held: a
  // worker that has gone away must not leave Eye Shield without any answer.
  const SIBLING_REFRESH_WAIT_MS = 8000;
  try {
    window.__wardenOneContentConfig = () => bridgeSnapshot;
    window.__wardenOneContentConfigRequest = (need, cb) => {
      const wanted = Array.isArray(need) && need.length ? need : CONTENT_CONFIG_NEED;
      const covered = wanted.every((n) => CONTENT_CONFIG_NEED.indexOf(n) >= 0);
      if (covered && bridgeSnapshot) {
        let answered = false;
        const answer = () => {
          if (answered) return;
          answered = true;
          const snap = bridgeSnapshot;
          woTimeout(() => { try { cb(snap); } catch (_) {} }, 0);
        };
        if (acquisitionInFlight) {
          acquisitionWaiters.push(answer);
          woTimeout(answer, SIBLING_REFRESH_WAIT_MS);
          return;
        }
        answer();
        return;
      }
      bridgeFetchContentConfig(wanted, cb, SIBLING_CONFIG_ATTEMPTS);
    };
  } catch (_) {}

  // Relay live config changes (from the options/popup page) into the page.
  try {
    const smartFrameReloadedUrls = new Set();
    woOnMessage((msg, _sender, sendResponse) => {
      if (msg && msg.kind === 'config-update' && msg.overrides) sendConfig(msg.overrides);
      // Repair asks whether the engine answers the signed challenge; a page cannot answer for it.
      if (msg && msg.kind === 'wo-engine-status' && window === window.top) {
        let alive = false;
        try { alive = bridgeEngineSeen && engineAnswers(); } catch (_) { alive = false; }
        // `configured`: whether this document has received its settings yet (MV3-04). An engine
        // that answers but is still on compiled defaults is running, not confirmed.
        try { sendResponse({ ok: true, alive, seen: bridgeEngineSeen, fresh: BRIDGE_FRESH, configured: bridgeConfigReady }); } catch (_) {}
        return true;
      }
      if (msg && msg.kind === 'content-config-refresh') requestContentConfig();
      // A child frame refused a command-shaped clipboard write and has no engine to warn with;
      // the worker addressed this to frame 0 so the top frame's engine can show the ClickFix
      // panel over the whole page (SEC-06). Token-carried, like config, so the page cannot
      // tell the engine this happened when it did not.
      if (msg && msg.kind === 'frame-clickfix' && window === window.top) {
        const d = msg.detail && typeof msg.detail === 'object' ? msg.detail : {};
        const detail = { sample: String(d.sample || '').slice(0, 180), frameHost: String(d.frameHost || '').slice(0, 120) };
        postToPage(signed('frame-clickfix', JSON.stringify(detail), { source: 'wardenone', kind: 'frame-clickfix', token: TOKEN, detail }));
      }
      if (msg && msg.kind === 'smart-script-route-changed') {
        smartFrameReloadedUrls.clear();
        armSmartPlayerObservation();
        if (Date.now() - smartPlayerTrustedIntentAt <= 3000) sendSmartPlayerIntent();
        try { sendResponse({ ok: true }); } catch (_) {}
        return true;
      }
      if (msg && msg.kind === 'smart-script-reload-frame') {
        let expected = '';
        let current = '';
        // Player embeds routinely rewrite their own URL (query/token churn) between
        // the blocked request and this message arriving. Requiring an exact match
        // rejected the reload and stranded the recovery, so match on same-origin
        // plus same path instead -- still never reloads a frame that has navigated
        // somewhere else, which is what this guard exists to prevent.
        let sameFrame = false;
        const failedHost = String(msg.failedHost || '').replace(/^\.+|\.+$/g, '').toLowerCase();
        const recoveryStage = Number(msg.recoveryStage);
        try {
          const expectedUrl = new URL(String(msg.expectedUrl || ''));
          const currentUrl = new URL(location.href);
          expectedUrl.hash = '';
          currentUrl.hash = '';
          expected = expectedUrl.href;
          current = currentUrl.href;
          sameFrame = expected === current
            || (expectedUrl.origin === currentUrl.origin && expectedUrl.pathname === currentUrl.pathname);
        } catch (_) {}
        const reloadKey = expected + '|' + failedHost + '|stage-' + String(recoveryStage);
        if (!expected || !sameFrame || !failedHost || !failedHost.includes('.')
          || !/^[a-z0-9.-]+$/i.test(failedHost) || failedHost.includes('..')
          || (recoveryStage !== 1 && recoveryStage !== 2)
          || smartFrameReloadedUrls.has(reloadKey)) {
          try { sendResponse({ ok: false }); } catch (_) {}
          return true;
        }
        smartFrameReloadedUrls.add(reloadKey);
        if (smartFrameReloadedUrls.size > 16) smartFrameReloadedUrls.delete(smartFrameReloadedUrls.values().next().value);
        try { sendResponse({ ok: true }); } catch (_) {}
        woTimeout(() => { try { location.reload(); } catch (_) {} }, 0);
        return true;
      }
    });
  } catch (_) {}

  // Safe Browsing relay: MAIN-world guards ask for a URL reputation verdict, but
  // only the background worker can read the saved API key. Results are posted
  // back with the same per-load token used by config messages.
  // A verdict is signed over its request id and its body, so the page -- which sees the id
  // leave -- cannot answer first with a clean one (SEC-02). The engine keeps the request
  // pending until a reply that verifies arrives.
  const postSafeBrowsingReply = (id, result) => {
    postToPage(signed('safe-browsing', id + '\n' + JSON.stringify(result), { source: 'wardenone-safe-browsing', token: TOKEN, id, result }));
  };
  try {
    const SAFE_BROWSING_CONTEXTS = new Set(['link', 'paste', 'form']);
    woOn(document, 'wo-safe-browsing-check', (e) => {
      const d = (e && e.detail) || {};
      const id = String(d.id || '');
      const url = String(d.url || '');
      const context = String(d.context || '').slice(0, 24);
      if (d.token !== TOKEN) return;
      if (!id || !/^https?:\/\//i.test(url)) return;
      if (url.length > 2048 || !SAFE_BROWSING_CONTEXTS.has(context)) return;
      if (!safeBrowsingIntentAllowed(url, context)) {
        postSafeBrowsingReply(id, { ok: false, error: 'No recent user intent for this reputation check.' });
        return;
      }
      if (!bridgeRateOk('safe-browsing-check', 45, 60000)) {
        postSafeBrowsingReply(id, { ok: false, error: 'Rate limited by WardenOne.' });
        return;
      }
      chrome.runtime.sendMessage({ kind: 'safe-browsing-check', url, context }, (res) => { void chrome.runtime.lastError;
        postSafeBrowsingReply(id, publicSafeBrowsingResult(res));
      });
    }, true);
  } catch (_) {}

  // Narrow MAIN-world -> background relay. content.js runs in the page's MAIN
  // world so it cannot rely on chrome.runtime directly; only these vetted message
  // kinds are forwarded through the isolated bridge.
  try {
    const relayPageHost = () => String(location.hostname || '').replace(/^www\./, '').toLowerCase();
    const relaySamePageHost = (host) => {
      const clean = String(host || '').replace(/^www\./, '').toLowerCase();
      const here = relayPageHost();
      return !!(clean && here && clean === here);
    };
    let relayRequestSeqSeen = 0;
    const relayRequestSigned = (raw, body) => {
      const seq = Number(raw && raw.rseq);
      if (!KEY_PADS || !Number.isInteger(seq) || seq <= relayRequestSeqSeen) return false;
      if (!__woAuth.same(raw.rmac, __woAuth.hmac(KEY_PADS, 'bg-request\n' + seq + '\n' + __woAuth.canon(body, 0)))) return false;
      relayRequestSeqSeen = seq;
      return true;
    };
    const relayAllowedMessage = (raw) => {
      const msg = Object.assign({}, raw || {});
      if (msg.kind === 'adshield-cosmetic') {
        const hostname = String(msg.hostname || '').replace(/^www\./, '').toLowerCase();
        if (!hostname || !/^[a-z0-9.-]+$/i.test(hostname)) return null;
        if (!relaySamePageHost(hostname)) return null;
        return { kind: 'adshield-cosmetic', hostname, playerPage: msg.playerPage === true };
      }
      /* Silencing one kind of notice. The page can only name a warning TYPE and
         a duration -- never a host, never a setting -- so the worst a hostile
         page can do with this channel is quieten a card about itself, which it
         could already achieve by not triggering one. */
      /* 'I showed this one.' Same narrow shape as the mute: a type and nothing
         else. The host is taken from the sending tab by the worker, never from
         the page, so a page cannot claim to have shown a notice on someone
         else's site and silence it there. */
      /* SEC-14: both were reachable with the public token alone -- one forged mute silenced a
         class of security notices on every site, for good. They now carry the engine's signature
         over exactly these fields, with a sequence that only moves forward. */
      if (msg.kind === 'toast-shown') {
        const type = String(msg.type || '');
        if (!/^[a-z_]{3,60}$/.test(type)) return null;
        if (!relayRequestSigned(msg, { kind: 'toast-shown', type: msg.type })) return null;
        return { kind: 'toast-shown', type };
      }
      if (msg.kind === 'mute-toast') {
        const type = String(msg.type || '');
        if (!/^[a-z_]{3,60}$/.test(type)) return null;
        const minutes = Number(msg.minutes);
        if (![60, 120, 480, 0].includes(minutes)) return null;
        if (!relayRequestSigned(msg, { kind: 'mute-toast', type: msg.type, minutes: msg.minutes })) return null;
        return { kind: 'mute-toast', type, minutes };
      }
      if (msg.kind === 'domain-age') {
        const domain = String(msg.domain || '').replace(/^www\./, '').toLowerCase();
        if (!domain || !/^[a-z0-9.-]+$/i.test(domain)) return null;
        if (!relaySamePageHost(domain)) return null;
        return { kind: 'domain-age', domain };
      }
      return null;
    };
    const postBackgroundReply = (id, result) => {
      postToPage(signed('bg-response', id + '\n' + JSON.stringify(result), { source: 'wardenone-bg-response', token: TOKEN, id, result }));
    };
    woOn(document, 'wo-background-message', (e) => {
      const d = (e && e.detail) || {};
      const id = String(d.id || '');
      if (d.token !== TOKEN || !id) return;
      const message = relayAllowedMessage(d.message);
      if (!message) return;
      if (!bridgeRateOk('background-relay-' + message.kind, 20, 60000)) {
        postBackgroundReply(id, { ok: false, error: 'Rate limited by WardenOne.' });
        return;
      }
      chrome.runtime.sendMessage(message, (res) => { void chrome.runtime.lastError;
        postBackgroundReply(id, res || { ok: false, error: 'No WardenOne response' });
      });
    }, true);
  } catch (_) {}

  // Cookie reload-loop escape. The bridge now BUILDS this notice rather than watching the page
  // for one, because the previous arrangement could not tell WardenOne's button from a copy of
  // it. The engine detects the loop -- it is the side that sees the navigations -- but it runs in
  // world MAIN, which is the page's own JS context, so anything it creates is indistinguishable
  // from something the page created. Only the isolated world can own a node the page cannot
  // reach, and only the owner of the node can safely act on a click on it.
  //
  // Honest about what this does and does not close: a page can still observe the token and ask
  // for the notice to be shown, because the token is not a secret. What it can no longer do is
  // control the words next to the button, or collect the click. The user sees WardenOne's own
  // text, saying cookies are blocked and that allowing them applies to this site -- and the
  // permission changes only on a trusted click on a node inside our closed shadow root.
  try {
    const cookieStopKey = () => '__wo_rlstop_' + String(location.hostname || '');
    let cookieOverlay = null;
    let cookieAllowInFlight = false;

    const showReloadLoopNotice = () => {
      if (cookieOverlay) { cookieOverlay.mount(); return; }
      cookieOverlay = woOwnedOverlay('rg-reload-loop');
      const root = cookieOverlay.root();
      if (!root) { cookieOverlay = null; return; }

      const panel = document.createElement('div');
      panel.setAttribute('style', 'all:initial!important;position:fixed!important;left:50%!important;'
        + 'bottom:24px!important;transform:translateX(-50%)!important;max-width:440px!important;'
        + 'width:calc(100vw - 32px)!important;box-sizing:border-box!important;'
        + 'background:rgba(250,243,253,.97)!important;backdrop-filter:blur(16px)!important;'
        + '-webkit-backdrop-filter:blur(16px)!important;border:1px solid rgba(176,106,212,.3)!important;'
        + 'border-radius:16px!important;padding:16px 18px!important;'
        + 'box-shadow:0 16px 48px rgba(80,30,110,.35)!important;'
        + 'font-family:Nunito,system-ui,sans-serif!important;');

      const title = document.createElement('div');
      title.setAttribute('style', 'all:initial!important;display:block!important;'
        + 'font-family:Quicksand,system-ui,sans-serif!important;font-weight:700!important;'
        + 'font-size:14px!important;color:#2d1b40!important;margin:0 0 5px 0!important;');
      title.textContent = 'Stopped a reload loop';
      panel.appendChild(title);

      const body = document.createElement('div');
      body.setAttribute('style', 'all:initial!important;display:block!important;'
        + 'font-size:12.5px!important;color:#6a5685!important;line-height:1.5!important;'
        + 'margin:0 0 12px 0!important;font-family:Nunito,system-ui,sans-serif!important;');
      body.textContent = "This site keeps reloading because WardenOne is blocking its cookies and it can't"
        + ' start a session. Cookies are still blocked. You can allow cookies just for this site to'
        + ' use it normally.';
      panel.appendChild(body);

      const row = document.createElement('div');
      row.setAttribute('style', 'all:initial!important;display:flex!important;gap:8px!important;'
        + 'flex-wrap:wrap!important;');

      const allow = document.createElement('button');
      allow.setAttribute('style', 'all:initial!important;flex:none!important;cursor:pointer!important;'
        + 'background:linear-gradient(135deg,#b06ad4,#e07ab0)!important;color:#fff!important;'
        + 'border-radius:10px!important;padding:9px 15px!important;'
        + 'font-family:Quicksand,system-ui,sans-serif!important;font-weight:700!important;'
        + 'font-size:12.5px!important;');
      allow.textContent = 'Allow cookies here';
      // Bound to this exact node, not to the document. There is no selector to match and no
      // element to forge: a page cannot obtain a reference to a node in a closed shadow root, so
      // it cannot dispatch on it either. owns() is belt and braces for the fallback path where
      // attachShadow was unavailable.
      woOn(allow, 'click', (e) => {
        if (cookieAllowInFlight || !e || e.isTrusted === false) return;
        if (!cookieOverlay || !cookieOverlay.owns(allow)) return;
        cookieAllowInFlight = true;
        try { allow.disabled = true; allow.textContent = 'Allowing...'; } catch (_) {}
        chrome.runtime.sendMessage({ kind: 'set-site-permission', url: location.href, key: 'cookies', setting: 'allow' }, (res) => {
          void chrome.runtime.lastError;
          if (chrome.runtime.lastError || !res || res.ok === false) {
            cookieAllowInFlight = false;
            try { allow.disabled = false; allow.textContent = 'Allow cookies here'; } catch (_) {}
            return;
          }
          try { sessionStorage.removeItem(cookieStopKey()); } catch (_) {}
          try { location.reload(); } catch (_) {}
        });
      });
      row.appendChild(allow);

      const dismiss = document.createElement('button');
      dismiss.setAttribute('style', 'all:initial!important;flex:none!important;cursor:pointer!important;'
        + 'border:1px solid rgba(176,106,212,.3)!important;background:rgba(176,106,212,.1)!important;'
        + 'color:#7a5f93!important;border-radius:10px!important;padding:9px 15px!important;'
        + 'font-family:Quicksand,system-ui,sans-serif!important;font-weight:700!important;'
        + 'font-size:12.5px!important;');
      dismiss.textContent = 'Keep blocked';
      // Dismiss stops the self-healing too, or the notice would reappear immediately.
      woOn(dismiss, 'click', (e) => {
        if (!e || e.isTrusted === false) return;
        const overlay = cookieOverlay;
        cookieOverlay = null;
        try { if (overlay) overlay.destroy(); } catch (_) {}
      });
      row.appendChild(dismiss);

      panel.appendChild(row);
      root.appendChild(panel);
      cookieOverlay.dialog({ label: 'WardenOne: this page is reloading repeatedly',
        description: 'A choice is needed before the page can settle.' });
      cookieOverlay.mount();
    };

    woOn(window, 'message', (e) => {
      if (e.source !== window || !e.data) return;
      /* Signed like the media report: the token alone let any page raise WardenOne's own
         "reloading repeatedly" panel over itself. */
      if (e.data.source !== 'wardenone-reload-loop' || e.data.token !== TOKEN || !pageNoticeSigned('reload-loop', e.data, '')) return;
      showReloadLoopNotice();
    });
  } catch (_) {}

  // ---- Memory Shield: form-dirty + active-media tracking ----
  // So Memory Shield never sleeps a tab where the user has typed into a form (and
  // would lose their input on discard+reload), we watch for input on form fields
  // and answer a background query about whether this page has unsaved form data.
  // We ALSO track whether the page is actively using the camera/microphone, so a
  // video-call / recording tab is never slept out from under the user.
  // Computed at query time, never latched. The old version set a boolean the first time anything
  // was typed into any field -- a site search box counted -- and nothing ever set it false again:
  // not submit, not navigation, not clearing the field. On a single-page app the document lives
  // for the whole session, so one keystroke exempted the tab from Memory Shield permanently and
  // the feature quietly stopped working the more the browser was used.
  //
  // Scanning when asked is affordable because Memory Shield only asks when it is considering this
  // tab, not on every keystroke. Every uncertain answer here resolves to "dirty": this guard is
  // what stops the extension throwing away a tab holding unsaved work, so being wrong in the
  // permissive direction costs the user their typing, while being wrong the other way costs some
  // memory that was not reclaimed.
  const FORM_SCAN_CAP = 4000;

  // A field counts as edited only if it differs from what the markup shipped with -- otherwise
  // every page with a pre-filled form would look dirty before the user touched anything.
  const fieldIsEdited = (el) => {
    const tag = (el.tagName || '').toUpperCase();
    if (el.isContentEditable) return String(el.textContent || '').trim().length > 0;
    if (tag === 'SELECT') {
      const opts = el.options || [];
      for (let i = 0; i < opts.length; i++) {
        if (opts[i].selected !== opts[i].defaultSelected) return true;
      }
      return false;
    }
    if (tag === 'INPUT') {
      const type = (el.type || '').toLowerCase();
      if (type === 'submit' || type === 'button' || type === 'reset'
        || type === 'image' || type === 'hidden') return false;
      // Checkboxes and radios always carry a value, so compare state rather than value. The old
      // code read el.value here, which is "on" for an untouched checkbox -- so merely having one
      // on the page could mark the tab dirty.
      if (type === 'checkbox' || type === 'radio') return el.checked !== el.defaultChecked;
      if (type === 'file') return !!(el.files && el.files.length);
    }
    const value = String(el.value == null ? '' : el.value);
    if (!value.length) return false;
    if (typeof el.defaultValue === 'string' && value === el.defaultValue) return false;
    return true;
  };

  const pageHasUnsavedInput = () => {
    try {
      const fields = document.querySelectorAll(
        'input, textarea, select, [contenteditable=""], [contenteditable="true"]');
      const limit = Math.min(fields.length, FORM_SCAN_CAP);
      for (let i = 0; i < limit; i++) {
        try {
          if (fieldIsEdited(fields[i])) return true;
        } catch (_) {
          return true;
        }
      }
      // More fields than we were willing to scan: unknown, so protect the tab.
      if (fields.length > limit) return true;
      return false;
    } catch (_) {
      return true;
    }
  };
  // Detect active camera/mic by wrapping getUserMedia in THIS (isolated) world.
  // Note: page scripts call getUserMedia in the MAIN world; to catch that too we
  // also listen for a signal Media Shield can post. As a robust fallback, we check
  // navigator.mediaDevices for active tracks periodically isn't possible, so we
  // rely on the wrap + the MAIN-world relay below.
  // Streams captured in THIS world, asked about their own state rather than tracked by a flag.
  // MediaStreamTrack.stop() does not dispatch 'ended' -- per spec -- so the old listener-only
  // clear never ran for the ordinary case of a page stopping its own capture, and the flag stayed
  // true for the life of the page.
  const liveStreams = new Set();

  const pageHasLiveCapture = () => {
    let live = false;
    for (const stream of Array.from(liveStreams)) {
      let any = false;
      try {
        any = stream.getTracks().some((t) => t.readyState === 'live');
      } catch (_) {
        any = false;
      }
      if (any) live = true;
      // Prune as we go, so a long call that starts and stops capture repeatedly cannot grow
      // this set without bound.
      else liveStreams.delete(stream);
    }
    return live;
  };

  // Honest scope: page scripts call getUserMedia in the MAIN world and never reach this wrapper,
  // so in practice the set above stays empty and the MAIN-world relay below is what reports a
  // page's camera or microphone. The wrapper is kept because it costs nothing and does catch
  // capture started from this world, but it is not the mechanism that matters.
  try {
    const md = navigator.mediaDevices;
    if (md && md.getUserMedia) {
      const orig = md.getUserMedia.bind(md);
      md.getUserMedia = function (...args) {
        return orig(...args).then((stream) => {
          try { liveStreams.add(stream); } catch (_) {}
          return stream;
        });
      };
    }
  } catch (_) {}
  // MAIN-world (content.js Media Shield) can tell us media went active/inactive. This flag is
  // answered back to Memory Shield in the memory-form-check reply, so a page that could post
  // {source:'wardenone-media', active:false} could present a live camera or microphone as idle
  // and become eligible to be slept or discarded. The token alone could not stop that -- a page
  // script can read it -- so the report is signed under the key, over a number that only moves
  // forward and the state it reports (pageNoticeSigned); anything else is ignored.
  let relayMediaActive = false;
  try {
    woOn(window, 'message', (e) => {
      if (e.source === window && e.data && e.data.source === 'wardenone-media'
        && e.data.token === TOKEN && pageNoticeSigned('media', e.data, e.data.active ? '1' : '0')) {
        relayMediaActive = !!e.data.active;
      }
    });
  } catch (_) {}
  try {
    woOnMessage((msg, sender, sendResponse) => {
      // Both answers are computed here rather than read from a flag set earlier. The reply shape
      // is unchanged, so background needs no change.
      if (msg && msg.kind === 'memory-form-check') {
        sendResponse({
          formDirty: pageHasUnsavedInput(),
          mediaActive: pageHasLiveCapture() || relayMediaActive,
        });
        return true;
      }
      if (msg && msg.kind === 'memory-throttle') {
        const host = String(location.hostname || '').replace(/^www\./, '').toLowerCase();
        if (host === 'twitch.tv' || host.endsWith('.twitch.tv')
          || host === 'youtube.com' || host.endsWith('.youtube.com')
          || host === 'youtube-nocookie.com' || host.endsWith('.youtube-nocookie.com')
          || host === 'youtu.be') {
          sendResponse({ ok: true, skipped: 'video-platform' });
          return true;
        }
        // Pause autoplaying audio/video in this (inactive) tab to cut CPU before a
        // possible later discard. We only pause media that is actually playing and
        // NOT user-initiated muted background players are left alone. Honest scope:
        // this reduces CPU from media; it cannot flush the tab's RAM cache.
        try {
          let paused = 0;
          document.querySelectorAll('video, audio').forEach((m) => {
            try { if (!m.paused && !m.ended) { m.pause(); paused++; } } catch (_) {}
          });
          sendResponse({ ok: true, paused });
        } catch (_) { sendResponse({ ok: false }); }
        return true;
      }
    });
  } catch (_) {}

  // ---- Script Drift Guard ----
  // Baselines third-party script hashes in the background and warns if the same
  // URL later serves different bytes with new suspicious behavior/hosts.
  try {
    if (window.top === window && /^https?:$/.test(location.protocol)) {
      let scriptDriftTimer = 0;
      let scriptDriftLastRun = 0;
      let scriptDriftWarnedKey = '';
      const cleanHost = (h) => String(h || '').replace(/^www\./, '').toLowerCase();
      const regSite = (h) => {
        const parts = cleanHost(h).split('.').filter(Boolean);
        if (parts.length <= 2) return parts.join('.');
        const last2 = parts.slice(-2).join('.');
        return /^(co|com|org|net|gov|ac|edu|gob|gouv)\.[a-z]{2}$/i.test(last2) ? parts.slice(-3).join('.') : last2;
      };
      const collectScriptUrls = () => {
        const pageSite = regSite(location.hostname);
        const seen = new Set();
        const out = [];
        try {
          const scripts = document.scripts || [];
          for (let i = 0; i < scripts.length && out.length < 20; i++) {
            const s = scripts[i];
            const src = s && s.src;
            if (!src) continue;
            let u;
            try { u = new URL(src, location.href); } catch (_) { continue; }
            if (u.protocol !== 'https:' && u.protocol !== 'http:') continue;
            if (u.protocol === 'http:' && location.protocol === 'https:') continue;
            const scriptSite = regSite(u.hostname);
            if (!scriptSite || scriptSite === pageSite) continue;
            u.hash = '';
            const href = u.href.slice(0, 900);
            if (seen.has(href)) continue;
            seen.add(href);
            out.push({ url: href });
          }
        } catch (_) {}
        return out;
      };
      const showScriptDriftWarning = (warning) => {
        if (!scriptDriftGuardOn() || bridgeSilentModeOn()) return;
        const w = warning && typeof warning === 'object' ? warning : {};
        const key = String(w.script || '') + ':' + String(w.newHash || '');
        if (key && key === scriptDriftWarnedKey) return;
        scriptDriftWarnedKey = key;
        try {
          /* Owned, not described: rendered into a closed shadow root, so the page this warns
             about cannot read it, reach into it, or delete it. Replacing an existing warning
             destroys the overlay WE built rather than searching the page for an element by id --
             the page could have planted that. */
          if (scriptDriftOverlay) { try { scriptDriftOverlay.destroy(); } catch (_) {} }
          scriptDriftOverlay = woOwnedOverlay('wo-script-drift');
          const root = scriptDriftOverlay.root();
          if (!root) return;
          const wrap = document.createElement('div');
          wrap.id = 'wo-script-drift';
          wrap.setAttribute('style', WO_MODAL.overlay('left'));
          const box = document.createElement('div');
          box.setAttribute('style', WO_MODAL.panel('700px'));
          const tag = document.createElement('div');
          const risk = String(w.risk || 'Medium');
          tag.setAttribute('style', WO_MODAL.tag(risk));
          tag.textContent = risk + ' script drift';
          const title = document.createElement('div');
          title.setAttribute('style', WO_MODAL.title);
          title.textContent = 'A third-party script changed unexpectedly';
          const body = document.createElement('div');
          body.setAttribute('style', WO_MODAL.body);
          const newBits = [];
          if (Array.isArray(w.newIndicators) && w.newIndicators.length) newBits.push('new behavior: ' + w.newIndicators.slice(0, 3).join(', '));
          if (Array.isArray(w.newHosts) && w.newHosts.length) newBits.push('new hosts: ' + w.newHosts.slice(0, 3).join(', '));
          body.textContent = 'WardenOne has seen this script URL before, but it now serves different code. ' + (newBits.length ? newBits.join('. ') + '. ' : '') + 'That can happen during normal deploys, but it is also how CDN/supply-chain compromises show up.';
          const meta = document.createElement('div');
          meta.setAttribute('style', WO_MODAL.meta);
          meta.textContent = 'Script: ' + String(w.script || w.scriptHost || 'third-party script').slice(0, 220) + ' | Hash ' + String(w.previousHash || '').slice(0, 8) + ' -> ' + String(w.newHash || '').slice(0, 8);
          const actions = document.createElement('div');
          actions.setAttribute('style', WO_MODAL.actions('flex-end'));
          const mkBtn = (label, primary) => {
            const btn = document.createElement('button');
            btn.setAttribute('style', WO_MODAL.button(primary, '12px'));
            btn.textContent = label;
            return btn;
          };
          const leave = mkBtn('Leave site', true);
          woOn(leave, 'click', (e) => {
            if (e && e.isTrusted === false) return;
            try { if (history.length > 1) history.back(); else location.href = 'about:blank'; } catch (_) { try { location.href = 'about:blank'; } catch (_) {} }
          });
          const dismiss = mkBtn('Dismiss', false);
          woOn(dismiss, 'click', (e) => {
            if (e && e.isTrusted === false) return;
            const overlay = scriptDriftOverlay;
            scriptDriftOverlay = null;
            try { if (overlay) overlay.destroy(); } catch (_) {}
          });
          actions.appendChild(leave);
          actions.appendChild(dismiss);
          box.appendChild(tag);
          box.appendChild(title);
          box.appendChild(body);
          box.appendChild(meta);
          box.appendChild(actions);
          wrap.appendChild(box);
          root.appendChild(wrap);
          /* Mounted only once the contents exist, so a half-built warning is never on screen. */
          if (scriptDriftOverlay) scriptDriftOverlay.dialog({
            label: 'WardenOne security warning: this site changed its code after loading',
            description: 'Review this before continuing.' });
          if (scriptDriftOverlay) scriptDriftOverlay.mount();
        } catch (_) {}
      };
      const runScriptDriftScan = () => {
        if (!scriptDriftGuardOn()) return;
        const now = Date.now();
        if (now - scriptDriftLastRun < 15000) return;
        scriptDriftLastRun = now;
        const scripts = collectScriptUrls();
        if (!scripts.length) return;
        try {
          chrome.runtime.sendMessage({ kind: 'script-drift-scan', scripts }, (res) => {
            if (chrome.runtime.lastError || !res || !res.ok || !Array.isArray(res.warnings) || !res.warnings.length) return;
            showScriptDriftWarning(res.warnings[0]);
          });
        } catch (_) {}
      };
      const scheduleScriptDriftScan = (delay) => {
        if (scriptDriftTimer) clearTimeout(scriptDriftTimer);
        scriptDriftTimer = woTimeout(() => {
          scriptDriftTimer = 0;
          runScriptDriftScan();
        }, Number(delay) || 1200);
      };
      if (document.readyState === 'loading') woOn(document, 'DOMContentLoaded', () => scheduleScriptDriftScan(1500), { once: true });
      else scheduleScriptDriftScan(1000);
      woOn(document, 'wo-bridge-config-ready', () => scheduleScriptDriftScan(300), { once: true });
      try {
        const driftUnwatch = domWatch((muts) => {
          for (const mut of muts || []) {
            const added = (mut && mut.addedNodes) || [];
            for (let i = 0; i < added.length; i++) {
              const n = added[i];
              if (n && n.nodeType === 1 && ((n.tagName || '').toUpperCase() === 'SCRIPT' || (n.querySelector && n.querySelector('script[src]')))) {
                if (!scriptDriftGuardOn()) return;
                scheduleScriptDriftScan(2500);
                return;
              }
            }
          }
        }, true);
        woTimeout(driftUnwatch, 60000);
      } catch (_) {}
    }
  } catch (_) {}

  // ---- Permission Chain Guard ----
  // A site asking for one capability is often normal. A site asking for several
  // sensitive capabilities in one visit can be a scam chain, so MAIN-world API
  // hooks report coarse request events here and the background scores the combo.
  try {
    if (window.top === window && /^https?:$/.test(location.protocol)) {
      const PERM_KEYS = new Set([
        'notifications', 'camera', 'microphone', 'screen', 'clipboard-read',
        'clipboard-write', 'location', 'file-open', 'file-save', 'directory',
        'file-upload', 'automatic-downloads',
      ]);
      const PERM_ACTIONS = new Set(['request', 'granted', 'denied', 'selected', 'used', 'error']);
      let permChainShownAt = 0;
      let permChainShownKey = '';

      const cleanPermSignal = (raw) => {
        const d = raw && typeof raw === 'object' ? raw : {};
        const permission = String(d.permission || '').toLowerCase().replace(/_/g, '-').trim();
        if (!PERM_KEYS.has(permission)) return null;
        const action = String(d.action || 'request').toLowerCase().replace(/[^a-z0-9_-]+/g, '-');
        return {
          permission,
          action: PERM_ACTIONS.has(action) ? action : 'request',
          result: String(d.result || '').slice(0, 40),
          userGesture: !!d.userGesture,
        };
      };

      const textList = (items, empty) => {
        const arr = Array.isArray(items) ? items.filter(Boolean).slice(0, 8) : [];
        return arr.length ? arr.join(', ') : empty;
      };

      const showPermissionChainWarning = (verdict) => {
        if (!permissionChainGuardOn() || bridgeSilentModeOn()) return;
        const v = verdict && typeof verdict === 'object' ? verdict : {};
        const risk = String(v.risk || 'Medium');
        const key = risk + ':' + textList(v.permissions, '');
        const now = Date.now();
        if (key === permChainShownKey && now - permChainShownAt < 10 * 60 * 1000) return;
        permChainShownKey = key;
        permChainShownAt = now;
        try {
          /* Owned, not described: rendered into a closed shadow root, so the page this warns
             about cannot read it, reach into it, or delete it. Replacing an existing warning
             destroys the overlay WE built rather than searching the page for an element by id --
             the page could have planted that. */
          if (permChainOverlay) { try { permChainOverlay.destroy(); } catch (_) {} }
          permChainOverlay = woOwnedOverlay('wo-permission-chain');
          const root = permChainOverlay.root();
          if (!root) return;
          const wrap = document.createElement('div');
          wrap.id = 'wo-permission-chain';
          wrap.setAttribute('style', WO_MODAL.overlay('left'));
          const box = document.createElement('div');
          box.setAttribute('style', WO_MODAL.panel('680px'));
          const tag = document.createElement('div');
          tag.setAttribute('style', WO_MODAL.tag(risk));
          tag.textContent = risk + ' permission chain';
          const title = document.createElement('div');
          title.setAttribute('style', WO_MODAL.title);
          title.textContent = 'This site is asking for a lot of power';
          const body = document.createElement('div');
          body.setAttribute('style', WO_MODAL.body);
          body.textContent = 'WardenOne saw a chain of sensitive permission requests from this site: ' + textList(v.permissions, 'multiple permissions') + '. ' + (Array.isArray(v.reasons) && v.reasons.length ? v.reasons[0] + '. ' : '') + 'You may want to set unused permissions back to Ask or Block.';
          const allowed = document.createElement('div');
          allowed.setAttribute('style', WO_MODAL.meta);
          allowed.textContent = 'Currently allowed here: ' + textList(v.allowed, 'none detected by Chrome settings');
          const actions = document.createElement('div');
          actions.setAttribute('style', WO_MODAL.actions('flex-end'));
          const status = document.createElement('div');
          status.setAttribute('style', WO_MODAL.status);

          const mkBtn = (label, primary) => {
            const btn = document.createElement('button');
            btn.setAttribute('style', WO_MODAL.button(primary, '12px'));
            btn.textContent = label;
            return btn;
          };
          const reset = mkBtn('Reset site permissions', true);
          woOn(reset, 'click', (e) => {
            if (e && e.isTrusted === false) return;
            reset.disabled = true;
            status.textContent = 'Resetting permissions for this site...';
            try {
              chrome.runtime.sendMessage({ kind: 'reset-site-permissions', url: location.href }, (res) => {
                if (chrome.runtime.lastError || !res || !res.ok) {
                  status.textContent = 'Could not reset automatically. Open Chrome settings and set unused permissions to Ask or Block.';
                  reset.disabled = false;
                  return;
                }
                status.textContent = 'Reset supported permissions. Reload this site if it still behaves oddly.';
                reset.textContent = 'Reset done';
              });
            } catch (_) {
              status.textContent = 'Could not reset automatically.';
              reset.disabled = false;
            }
          });
          const settings = mkBtn('Open Chrome settings', false);
          woOn(settings, 'click', (e) => {
            if (e && e.isTrusted === false) return;
            try {
              chrome.runtime.sendMessage({ kind: 'open-site-settings', url: location.href }, () => { void chrome.runtime.lastError; });
              status.textContent = 'Chrome settings opened. Set unused permissions to Ask or Block.';
            } catch (_) {}
          });
          const dismiss = mkBtn('Dismiss', false);
          woOn(dismiss, 'click', (e) => {
            if (e && e.isTrusted === false) return;
            const overlay = permChainOverlay;
            permChainOverlay = null;
            try { if (overlay) overlay.destroy(); } catch (_) {}
          });
          actions.appendChild(reset);
          actions.appendChild(settings);
          actions.appendChild(dismiss);
          box.appendChild(tag);
          box.appendChild(title);
          box.appendChild(body);
          box.appendChild(allowed);
          box.appendChild(status);
          box.appendChild(actions);
          wrap.appendChild(box);
          root.appendChild(wrap);
          /* Mounted only once the contents exist, so a half-built warning is never on screen. */
          if (permChainOverlay) permChainOverlay.dialog({
            label: 'WardenOne security warning: this site requested several sensitive permissions',
            description: 'Review what this site is asking for.' });
          if (permChainOverlay) permChainOverlay.mount();
        } catch (_) {}
      };

      woOn(document, 'wo-permission-signal', (e) => {
        const d = (e && e.detail) || {};
        if (d.token !== TOKEN || !permissionChainGuardOn() || !permissionSignalSigned(d)) return;
        const signal = cleanPermSignal(d);
        if (!signal) return;
        if (!bridgeRateOk('permission-chain-' + signal.permission, 10, 60000)) return;
        try {
          chrome.runtime.sendMessage(Object.assign({ kind: 'permission-chain' }, signal), (res) => {
            if (chrome.runtime.lastError || !res || !res.ok || !res.warn) return;
            showPermissionChainWarning(res.verdict || {});
          });
        } catch (_) {}
      }, true);
    }
  } catch (_) {}

  // ---- Browser Abuse Guard: REMOVED (perf, weak machines) ----
  // The 1s main-thread-lag setInterval + longtask PerformanceObserver were
  // removed. They ran on every top-level page forever, could not stop a true
  // hard-freeze (the renderer locks before any extension code runs), only
  // produced a best-effort "leave?" nag on soft pulsing-freeze pages the user
  // can already close, and false-fired on heavy legit apps. Net win: one fewer
  // permanent per-tab CPU wakeup and observer.

  // ---- Login Page Age Check ----
  // A password field on a brand-new domain is a strong phishing signal. We detect the
  // password field here (the ISOLATED world has both the DOM and chrome.*), ask the
  // background for the domain's registration age (keyless RDAP, cached), and if the
  // domain is very new we warn BEFORE the user types a password. Top frame only, once.
  try {
    if (window.top === window && /^https?:$/.test(location.protocol)) {
      let laChecked = false, laShown = false;
      const laVisiblePassword = () => {
        const fields = document.querySelectorAll('input[type="password" i]');
        for (const f of fields) {
          try {
            if (f.disabled || f.readOnly) continue;
            const r = f.getBoundingClientRect ? f.getBoundingClientRect() : null;
            if ((r && r.width > 0 && r.height > 0) || f.offsetParent !== null) return true;
          } catch (_) {}
        }
        return false;
      };
      const laInterstitial = (verdict) => {
        if (laShown || !loginAgeGuardOn() || bridgeSilentModeOn()) return;
        laShown = true;
        try {
          if (loginAgeOverlay) return;
          if (!document.body && !document.documentElement) return;
          const reasons = Array.isArray(verdict && verdict.reasons) ? verdict.reasons : [];
          const domain = String((verdict && verdict.domain) || location.hostname || '');
          const ageDays = typeof (verdict && verdict.ageDays) === 'number' ? verdict.ageDays : null;
          const wrap = document.createElement('div');
          wrap.id = 'wo-login-age';
          wrap.setAttribute('style', WO_MODAL.overlay('center') + 'flex-direction:column!important;gap:12px!important;');
          const txt = document.createElement('div');
          txt.setAttribute('style', WO_MODAL.panel('620px', '12px') + 'text-align:center!important;font:700 15px/1.5 Nunito,system-ui,sans-serif!important;');
          const riskSummary = reasons.length ? ' Signals: ' + reasons.slice(0, 4).join('; ') + '.' : '';
          const ageText = typeof ageDays === 'number' ? (ageDays <= 1 ? ' registered today' : ' registered ' + ageDays + ' day(s) ago') : '';
          txt.textContent = 'Do not enter your password here. WardenOne found phishing-risk signals for ' + domain + (ageText ? ' (' + ageText.trim() + ')' : '') + '.' + riskSummary;
          const x = document.createElement('button');
          x.setAttribute('style', WO_MODAL.button(false, '12px'));
          x.textContent = 'Dismiss warning';
          /* laShown above is what stops this warning returning, so clearing the handle here
             costs nothing and keeps all three interstitials closing the same way. */
          woOn(x, 'click', (e) => {
            if (e && e.isTrusted === false) return;
            const overlay = loginAgeOverlay;
            loginAgeOverlay = null;
            try { if (overlay) overlay.destroy(); } catch (_) {}
          });
          const leave = document.createElement('button');
          leave.setAttribute('style', WO_MODAL.button(true, '12px'));
          leave.textContent = 'Leave site';
          woOn(leave, 'click', (e) => {
            if (e && e.isTrusted === false) return;
            try { if (history.length > 1) history.back(); else location.href = 'about:blank'; } catch (_) { try { location.href = 'about:blank'; } catch (_) {} }
          });
          wrap.appendChild(txt); wrap.appendChild(leave); wrap.appendChild(x);
          /* The highest-stakes warning WardenOne produces -- it says this site is probably
             phishing -- and the site it accuses could delete it with a single call. A closed
             shadow root puts it out of reach, and the mount re-places the host if the page
             removes it anyway. */
          loginAgeOverlay = woOwnedOverlay('wo-login-age');
          const laRoot = loginAgeOverlay.root();
          if (!laRoot) return;
          laRoot.appendChild(wrap);
          loginAgeOverlay.dialog({
            label: 'WardenOne phishing warning: this sign-in page is on a brand-new domain',
            description: 'Do not enter a password until you have checked the address.' });
          loginAgeOverlay.mount();
        } catch (_) {}
      };
      const laCheck = () => {
        if (laChecked || laShown || !loginAgeGuardOn() || !laVisiblePassword()) return;
        laChecked = true;
        try {
          chrome.runtime.sendMessage({ kind: 'login-domain-age', domain: location.hostname, url: location.href }, (res) => {
            if (chrome.runtime.lastError || !res || !res.ok) return;
            if (res.hardBlock || res.isNew) laInterstitial(res);
          });
        } catch (_) {}
      };
      if (document.readyState === 'loading') woOn(document, 'DOMContentLoaded', laCheck, { once: true });
      else laCheck();
      woOn(document, 'wo-bridge-config-ready', laCheck, { once: true });
      try {
        let laP = false;
        // PERF (weak machines): a login form appears within the first seconds of
        // load, so once we've checked (or shown a warning) stop watching. Releasing
        // this subscription no longer stops the other guards -- the shared observer
        // stays connected while anyone else is still listening.
        const laUnwatch = domWatch(() => {
          if (laChecked || laShown) { laUnwatch(); return; }
          if (laP) return;
          laP = true;
          woTimeout(() => { laP = false; laCheck(); }, 600);
        }, true);
        woTimeout(laUnwatch, 60000);
      } catch (_) {}
    }
  } catch (_) {}
  // The key is handed over last, once every listener above exists: the engine flushes its
  // queued "installed" the moment it has the key, and the wo-event listener must be there to
  // receive it. Nothing but content scripts can be running at this point of a document_start
  // injection; if something has been built already, this bridge was injected late and the key
  // stays here.
  deliverKey();
  try { window.__wardenOneBridgeReadyVersion = BRIDGE_VERSION; } catch (_) {}
})();