nodebb-plugin-ezoic-infinite 1.8.68 → 1.8.70

package/public/client.js

@@ -1,45 +1,90 @@
 /**
- * NodeBB Ezoic Infinite Ads — client.js v2.4.0
+ * NodeBB Ezoic Infinite Ads — client.js v36
  *
- * Architecture: proven v50 core + targeted improvements.
- * Ezoic API: showAds() + destroyPlaceholders() per official docs.
- * Key features: O(1) recycle via wrapsByClass, MutationObserver fill detect,
- * conservative empty check, aria-hidden + TCF protection, retry boot for
- * Cloudflare/async timing.
+ * Historique des corrections majeures
+ * ────────────────────────────────────
+ * v18  Ancrage stable par data-pid / data-index au lieu d'ordinalMap fragile.
+ *
+ * v19  Intervalle global basé sur l'ordinal absolu (data-index), pas sur
+ *      la position dans le batch courant.
+ *
+ * v20  Table KIND : anchorAttr / ordinalAttr / baseTag par kindClass.
+ *      Fix fatal catégories : data-cid au lieu de data-index inexistant.
+ *      IO fixe (une instance, jamais recréée).
+ *      Fix TCF locator : MutationObserver recrée l'iframe si ajaxify la retire.
+ *
+ * v25  Fix scroll-up / virtualisation NodeBB : decluster + grace period.
+ *
+ * v26  Suppression définitive du recyclage d'id (causait réinjection en haut).
+ *
+ * v27  pruneOrphans supprimé (faux-orphelins sur virtualisation NodeBB posts).
+ *
+ * v28  decluster supprimé. Wraps persistants pendant la session.
+ *
+ * v32  Retour anchorAttr = data-index pour ezoic-ad-between.
+ *      data-tid peut être absent → clés invalides → wraps empilés.
+ *      pruneOrphansBetween réactivé uniquement pour topics de catégorie :
+ *        – NodeBB NE virtualise PAS les topics dans une liste de catégorie,
+ *          les ancres (data-index) restent en DOM → prune safe et nécessaire
+ *          pour éviter l'empilement après scroll long.
+ *        – Toujours désactivé pour les posts : NodeBB virtualise les posts
+ *          hors-viewport → faux-orphelins → bug réinjection en haut.
+ *
+ * v34  moveDistantWrap — voir v38.
+ *
+ * v50  Suppression de bindLoginCheck() : NodeBB fait un rechargement complet
+ *      après login — filter:middleware.renderHeader re-évalue l'exclusion au
+ *      rechargement. Redondant depuis le fix normalizeExcludedGroups (v49).
+ *
+ * v43  Seuil de recyclage abaissé à -vh + unobserve avant recyclage.
+ *
+ * v42  Seuil -(IO_MARGIN + vh) (trop strict, peu de wraps éligibles).
+ *
+ * v41  Seuil -1vh (trop permissif sur mobile, ignorait IO_MARGIN).
+ *
+ * v40  Recyclage slots via destroyPlaceholders+define+displayMore avec délais.
+ *      Séquence : destroy → 300ms → define → 300ms → displayMore.
+ *      Testé manuellement : fonctionne. displayMore = API Ezoic infinite scroll.
+ *
+ * v38  Pool épuisé = fin de quota Ezoic par page-view. ez.refresh() interdit
+ *      sur la même page que ez.enable() — supprimé. moveDistantWrap supprimé :
+ *      déplacer un wrap "already defined" ne re-sert aucune pub. Pool épuisé →
+ *      break propre dans injectBetween. muteConsole : ajout warnings refresh.
+ *
+ * v36  Optimisations chemin critique (scroll → injectBetween) :
+ *      – S.wrapByKey Map<anchorKey,wrap> : findWrap() passe de querySelector
+ *        sur tout le doc à un lookup O(1). Mis à jour dans insertAfter,
+ *        dropWrap et cleanup.
+ *      – wrapIsLive allégé : pour les voisins immédiats on vérifie les
+ *        attributs du nœud lui-même sans querySelector global.
+ *      – MutationObserver : matches() vérifié avant querySelector() pour
+ *        court-circuiter les sous-arbres entiers ajoutés par NodeBB.
+ *
+ * v35  Revue complète prod-ready :
+ *      – initPools protégé contre ré-initialisation inutile (S.poolsReady).
+ *      – muteConsole élargit à "No valid placeholders for loadMore".
+ *      – Commentaires et historique nettoyés.
  */
 (function nbbEzoicInfinite() {
   'use strict';
 
-  // ── Constants ──────────────────────────────────────────────────────────────
-
-  const WRAP_CLASS = 'nodebb-ezoic-wrap';
-  const PH_PREFIX  = 'ezoic-pub-ad-placeholder-';
+  // ── Constantes ─────────────────────────────────────────────────────────────
 
-  const ATTR = {
-    ANCHOR:  'data-ezoic-anchor',
-    WRAPID:  'data-ezoic-wrapid',
-    CREATED: 'data-ezoic-created',
-    SHOWN:   'data-ezoic-shown',
-  };
-
-  const TIMING = {
-    EMPTY_CHECK_MS_1:  30_000,
-    EMPTY_CHECK_MS_2:  60_000,
-    MIN_PRUNE_AGE_MS:   8_000,
-    RECYCLE_MIN_AGE_MS: 5_000,
-    SHOW_THROTTLE_MS:     900,
-    BURST_COOLDOWN_MS:    200,
-    BLOCK_DURATION_MS:  1_500,
-    SHOW_TIMEOUT_MS:    7_000,
-    SHOW_RELEASE_MS:      700,
-    RECYCLE_DELAY_MS:     450,
-  };
+  const WRAP_CLASS  = 'nodebb-ezoic-wrap';
+  const PH_PREFIX   = 'ezoic-pub-ad-placeholder-';
+  const A_ANCHOR    = 'data-ezoic-anchor';   // "kindClass:stableId"
+  const A_WRAPID    = 'data-ezoic-wrapid';   // id Ezoic
+  const A_CREATED   = 'data-ezoic-created';  // timestamp création ms
+  const A_SHOWN     = 'data-ezoic-shown';    // timestamp dernier showAds ms
 
-  const MAX_INSERTS_RUN = 6;
-  const MAX_INFLIGHT    = 4;
-  const MAX_BURST_STEPS = 8;
-  const BURST_WINDOW_MS = 2_000;
+  const EMPTY_CHECK_MS    = 20_000;  // délai avant collapse d'un wrap vide post-show
+  const MIN_PRUNE_AGE_MS  = 8_000;   // délai de grâce avant pruning (stabilisation DOM)
+  const MAX_INSERTS_RUN   = 6;       // max insertions par appel runCore
+  const MAX_INFLIGHT      = 4;       // max showAds() simultanés
+  const SHOW_THROTTLE_MS  = 900;     // anti-spam showAds() par id
+  const BURST_COOLDOWN_MS = 200;     // délai min entre deux déclenchements de burst
 
+  // Marges IO larges et fixes — observer créé une seule fois au boot
   const IO_MARGIN_DESKTOP = '2500px 0px 2500px 0px';
   const IO_MARGIN_MOBILE  = '3500px 0px 3500px 0px';
 
@@ -49,50 +94,39 @@
     category: 'li[component="categories/category"]',
   };
 
+  /**
+   * Table KIND — source de vérité par kindClass.
+   *
+   * sel         sélecteur CSS complet des éléments cibles
+   * baseTag     préfixe tag pour querySelector d'ancre
+   *             (vide pour posts : le sélecteur commence par '[')
+   * anchorAttr  attribut DOM stable → clé unique du wrap
+   * ordinalAttr attribut 0-based pour le calcul de l'intervalle
+   *             null → fallback positionnel (catégories)
+   */
   const KIND = {
     'ezoic-ad-message':    { sel: SEL.post,     baseTag: '',   anchorAttr: 'data-pid',   ordinalAttr: 'data-index' },
     'ezoic-ad-between':    { sel: SEL.topic,    baseTag: 'li', anchorAttr: 'data-index', ordinalAttr: 'data-index' },
     'ezoic-ad-categories': { sel: SEL.category, baseTag: 'li', anchorAttr: 'data-cid',   ordinalAttr: null         },
   };
 
-  const FILL_SEL = 'iframe, ins, img, video, [data-google-container-id], div[id$="__container__"]';
-
-  // ── Utility ────────────────────────────────────────────────────────────────
-
-  const now      = () => Date.now();
-  const isMobile = () => window.innerWidth < 768;
-  const normBool = v  => v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
-  const isFilled = n  => !!(n?.querySelector?.(FILL_SEL));
-
-  function parseIds(raw) {
-    const out = [], seen = new Set();
-    for (const v of String(raw || '').split(/[\r\n,\s]+/)) {
-      const n = parseInt(v, 10);
-      if (n > 0 && Number.isFinite(n) && !seen.has(n)) { seen.add(n); out.push(n); }
-    }
-    return out;
-  }
-
-  // ── State ──────────────────────────────────────────────────────────────────
+  // ── État global ────────────────────────────────────────────────────────────
 
   const S = {
     pageKey:      null,
-    kind:         null,
     cfg:          null,
     poolsReady:   false,
     pools:        { topics: [], posts: [], categories: [] },
     cursors:      { topics: 0,  posts: 0,  categories: 0  },
     mountedIds:   new Set(),
     lastShow:     new Map(),
-    wrapByKey:    new Map(),
-    wrapsByClass: new Map(),
     io:           null,
     domObs:       null,
-    mutGuard:     0,
-    blockedUntil: 0,
-    inflight:     0,
-    pending:      [],
+    mutGuard:     0,     // >0 : mutations DOM en cours (MutationObserver ignoré)
+    inflight:     0,     // showAds() en cours
+    pending:      [],    // ids en attente de slot inflight
     pendingSet:   new Set(),
+    wrapByKey:    new Map(),  // anchorKey → wrap DOM node
     runQueued:    false,
     burstActive:  false,
     burstDeadline: 0,
@@ -100,7 +134,13 @@
     lastBurstTs:  0,
   };
 
-  const isBlocked = () => now() < S.blockedUntil;
+  let blockedUntil = 0;
+
+  const ts        = () => Date.now();
+  const isBlocked = () => ts() < blockedUntil;
+  const isMobile  = () => { try { return window.innerWidth < 768; } catch (_) { return false; } };
+  const normBool  = v  => v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
+  const isFilled  = n  => !!(n?.querySelector?.('iframe, ins, img, video, [data-google-container-id]'));
 
   function mutate(fn) {
     S.mutGuard++;
@@ -111,10 +151,6 @@
 
   async function fetchConfig() {
     if (S.cfg) return S.cfg;
-    try {
-      const inline = window.__nbbEzoicCfg;
-      if (inline && typeof inline === 'object') { S.cfg = inline; return S.cfg; }
-    } catch (_) {}
     try {
       const r = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
       if (r.ok) S.cfg = await r.json();
@@ -122,6 +158,15 @@
     return S.cfg;
   }
 
+  function parseIds(raw) {
+    const out = [], seen = new Set();
+    for (const v of String(raw || '').split(/\r?\n/).map(s => s.trim()).filter(Boolean)) {
+      const n = parseInt(v, 10);
+      if (n > 0 && Number.isFinite(n) && !seen.has(n)) { seen.add(n); out.push(n); }
+    }
+    return out;
+  }
+
   function initPools(cfg) {
     if (S.poolsReady) return;
     S.pools.topics     = parseIds(cfg.placeholderIds);
@@ -141,7 +186,7 @@
     return location.pathname;
   }
 
-  function detectKind() {
+  function getKind() {
     const p = location.pathname;
     if (/^\/topic\//.test(p))                 return 'topic';
     if (/^\/category\//.test(p))              return 'categoryTopics';
@@ -152,213 +197,181 @@
     return 'other';
   }
 
-  function getKind() {
-    return S.kind || (S.kind = detectKind());
-  }
-
-  // ── DOM queries ────────────────────────────────────────────────────────────
+  // ── Items DOM ──────────────────────────────────────────────────────────────
 
   function getPosts() {
-    const all = document.querySelectorAll(SEL.post);
-    const out = [];
-    for (let i = 0; i < all.length; i++) {
-      const el = all[i];
-      if (!el.isConnected) continue;
-      if (!el.querySelector('[component="post/content"]')) continue;
-      const parent = el.parentElement?.closest(SEL.post);
-      if (parent && parent !== el) continue;
-      if (el.getAttribute('component') === 'post/parent') continue;
-      out.push(el);
-    }
-    return out;
+    return Array.from(document.querySelectorAll(SEL.post)).filter(el => {
+      if (!el.isConnected) return false;
+      if (!el.querySelector('[component="post/content"]')) return false;
+      const p = el.parentElement?.closest(SEL.post);
+      if (p && p !== el) return false;
+      return el.getAttribute('component') !== 'post/parent';
+    });
   }
 
   const getTopics     = () => Array.from(document.querySelectorAll(SEL.topic));
   const getCategories = () => Array.from(document.querySelectorAll(SEL.category));
 
-  // ── Anchor keys & wrap registry ────────────────────────────────────────────
-
-  function stableId(klass, el) {
-    const attr = KIND[klass]?.anchorAttr;
-    if (attr) {
-      const v = el.getAttribute(attr);
-      if (v != null && v !== '') return v;
-    }
-    const children = el.parentElement?.children;
-    if (!children) return 'i0';
-    for (let i = 0; i < children.length; i++) {
-      if (children[i] === el) return `i${i}`;
-    }
-    return 'i0';
-  }
-
-  const anchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
-
-  function findWrap(key) {
-    const w = S.wrapByKey.get(key);
-    return w?.isConnected ? w : null;
-  }
-
-  function getWrapSet(klass) {
-    let set = S.wrapsByClass.get(klass);
-    if (!set) { set = new Set(); S.wrapsByClass.set(klass, set); }
-    return set;
-  }
-
-  // ── GC disconnected wraps ──────────────────────────────────────────────────
-
-  function gcDisconnectedWraps() {
-    for (const [key, w] of Array.from(S.wrapByKey)) {
-      if (!w?.isConnected) S.wrapByKey.delete(key);
-    }
-    for (const [klass, set] of Array.from(S.wrapsByClass)) {
-      for (const w of Array.from(set)) {
-        if (w?.isConnected) continue;
-        set.delete(w);
-        const id = parseInt(w.getAttribute?.(ATTR.WRAPID), 10);
-        if (Number.isFinite(id)) {
-          S.mountedIds.delete(id);
-          S.lastShow.delete(id);
-        }
-      }
-      if (!set.size) S.wrapsByClass.delete(klass);
-    }
-  }
-
-  // ── Wrap lifecycle ─────────────────────────────────────────────────────────
+  // ── Wraps — détection ──────────────────────────────────────────────────────
 
+  /**
+   * Vérifie qu'un wrap a encore son ancre dans le DOM.
+   * Utilisé par adjacentWrap pour ignorer les wraps orphelins.
+   */
   function wrapIsLive(wrap) {
     if (!wrap?.classList?.contains(WRAP_CLASS)) return false;
-    const key = wrap.getAttribute(ATTR.ANCHOR);
+    const key = wrap.getAttribute(A_ANCHOR);
     if (!key) return false;
+    // Lookup O(1) dans le registre — vrai si le wrap EST encore dans le registre
+    // et connecté au DOM (le registre est tenu à jour par insertAfter/dropWrap).
     if (S.wrapByKey.get(key) === wrap) return wrap.isConnected;
+    // Fallback : registre pas encore à jour ou wrap non enregistré.
     const colonIdx = key.indexOf(':');
     const klass    = key.slice(0, colonIdx);
     const anchorId = key.slice(colonIdx + 1);
     const cfg = KIND[klass];
     if (!cfg) return false;
+    // Optimisation : si l'ancre est un frère direct du wrap, pas besoin
+    // de querySelector global — on cherche parmi les voisins immédiats.
     const parent = wrap.parentElement;
     if (parent) {
-      const sel = `${cfg.baseTag || ''}[${cfg.anchorAttr}="${anchorId}"]`;
       for (const sib of parent.children) {
-        if (sib !== wrap) {
-          try { if (sib.matches(sel)) return sib.isConnected; } catch (_) {}
-        }
+        if (sib === wrap) continue;
+        try {
+          if (sib.matches(`${cfg.baseTag || ''}[${cfg.anchorAttr}="${anchorId}"]`)) {
+            return sib.isConnected;
+          }
+        } catch (_) {}
       }
     }
+    // Dernier recours : querySelector global
     try {
-      return document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`)?.isConnected === true;
+      const found = document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`);
+      return !!(found?.isConnected);
     } catch (_) { return false; }
   }
 
-  const adjacentWrap = el => wrapIsLive(el.nextElementSibling) || wrapIsLive(el.previousElementSibling);
+  function adjacentWrap(el) {
+    return wrapIsLive(el.nextElementSibling) || wrapIsLive(el.previousElementSibling);
+  }
 
-  // ── Fill detection ─────────────────────────────────────────────────────────
+  // ── Ancres stables ─────────────────────────────────────────────────────────
 
-  function clearEmptyIfFilled(wrap) {
-    if (!wrap?.isConnected) return false;
-    const ph = wrap.querySelector(`[id^="${PH_PREFIX}"]`);
-    if (!ph || !isFilled(ph)) return false;
-    wrap.classList.remove('is-empty');
-    return true;
+  /**
+   * Retourne la valeur de l'attribut stable pour cet élément,
+   * ou un fallback positionnel si l'attribut est absent.
+   */
+  function stableId(klass, el) {
+    const attr = KIND[klass]?.anchorAttr;
+    if (attr) {
+      const v = el.getAttribute(attr);
+      if (v !== null && v !== '') return v;
+    }
+    let i = 0;
+    for (const s of el.parentElement?.children ?? []) {
+      if (s === el) return `i${i}`;
+      i++;
+    }
+    return 'i0';
   }
 
-  function scheduleUncollapseChecks(wrap) {
-    if (!wrap) return;
-    for (const ms of [500, 3000, 10000]) {
-      setTimeout(() => { try { clearEmptyIfFilled(wrap); } catch (_) {} }, ms);
-    }
+  const anchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
+
+  function findWrap(key) {
+    const w = S.wrapByKey.get(key);
+    return (w?.isConnected) ? w : null;
   }
 
-  // ── Pool management ────────────────────────────────────────────────────────
+  // ── Pool ───────────────────────────────────────────────────────────────────
 
+  /**
+   * Retourne le prochain id disponible dans le pool (round-robin),
+   * ou null si tous les ids sont montés.
+   */
   function pickId(poolKey) {
     const pool = S.pools[poolKey];
     if (!pool.length) return null;
     for (let t = 0; t < pool.length; t++) {
-      const idx = S.cursors[poolKey] % pool.length;
+      const i = S.cursors[poolKey] % pool.length;
       S.cursors[poolKey] = (S.cursors[poolKey] + 1) % pool.length;
-      const id = pool[idx];
+      const id = pool[i];
       if (!S.mountedIds.has(id)) return id;
     }
     return null;
   }
 
-  // ── Recycling ──────────────────────────────────────────────────────────────
-
-  function recycleWrap(klass, targetEl, newKey) {
+  /**
+   * Pool épuisé : recycle un wrap loin au-dessus du viewport.
+   * Séquence avec délais (destroyPlaceholders est asynchrone) :
+   *   destroy([id]) → 300ms → define([id]) → 300ms → displayMore([id])
+   * displayMore = API Ezoic prévue pour l'infinite scroll.
+   * Priorité : wraps vides d'abord, remplis si nécessaire.
+   */
+  function recycleAndMove(klass, targetEl, newKey) {
     const ez = window.ezstandalone;
     if (typeof ez?.destroyPlaceholders !== 'function' ||
-        typeof ez?.showAds             !== 'function') return null;
-
-    const threshold = -(3 * (window.innerHeight || 800));
-    const t = now();
-    let bestEmpty = null, bestEmptyY = Infinity;
-    let bestFull  = null, bestFullY  = Infinity;
+        typeof ez?.define             !== 'function' ||
+        typeof ez?.displayMore        !== 'function') return null;
 
-    const wraps = S.wrapsByClass.get(klass);
-    if (!wraps) return null;
+    const vh        = window.innerHeight || 800;
+    // Seuil : -1vh (hors viewport visible). On appelle unobserve(ph) juste
+    // après pour neutraliser l'IO — plus de showAds parasite possible.
+    const threshold = -vh;
+    let bestEmpty = null, bestEmptyBottom = Infinity;
+    let bestFilled = null, bestFilledBottom = Infinity;
 
-    for (const wrap of wraps) {
+    document.querySelectorAll(`.${WRAP_CLASS}.${klass}`).forEach(wrap => {
       try {
-        const created = parseInt(wrap.getAttribute(ATTR.CREATED) || '0', 10);
-        if (t - created < TIMING.RECYCLE_MIN_AGE_MS) continue;
-        const bottom = wrap.getBoundingClientRect().bottom;
-        if (bottom > threshold) continue;
+        const rect = wrap.getBoundingClientRect();
+        if (rect.bottom > threshold) return;
         if (!isFilled(wrap)) {
-          if (bottom < bestEmptyY) { bestEmptyY = bottom; bestEmpty = wrap; }
+          if (rect.bottom < bestEmptyBottom) { bestEmptyBottom = rect.bottom; bestEmpty = wrap; }
         } else {
-          if (bottom < bestFullY)  { bestFullY = bottom; bestFull = wrap; }
+          if (rect.bottom < bestFilledBottom) { bestFilledBottom = rect.bottom; bestFilled = wrap; }
         }
       } catch (_) {}
-    }
+    });
 
-    const best = bestEmpty ?? bestFull;
+    const best = bestEmpty ?? bestFilled;
     if (!best) return null;
-    const id = parseInt(best.getAttribute(ATTR.WRAPID), 10);
+    const id = parseInt(best.getAttribute(A_WRAPID), 10);
     if (!Number.isFinite(id)) return null;
-    const oldKey = best.getAttribute(ATTR.ANCHOR);
 
-    try {
+    const oldKey = best.getAttribute(A_ANCHOR);
+    // Neutraliser l'IO sur ce wrap avant déplacement — évite un showAds
+    // parasite si le nœud était encore dans la zone IO_MARGIN.
+    try { const ph = best.querySelector(`#${PH_PREFIX}${id}`); if (ph) S.io?.unobserve(ph); } catch (_) {}
+    mutate(() => {
+      best.setAttribute(A_ANCHOR,  newKey);
+      best.setAttribute(A_CREATED, String(ts()));
+      best.setAttribute(A_SHOWN,   '0');
+      best.classList.remove('is-empty');
       const ph = best.querySelector(`#${PH_PREFIX}${id}`);
-      if (ph) S.io?.unobserve(ph);
-    } catch (_) {}
+      if (ph) ph.innerHTML = '';
+      targetEl.insertAdjacentElement('afterend', best);
+    });
+    if (oldKey && S.wrapByKey.get(oldKey) === best) S.wrapByKey.delete(oldKey);
+    S.wrapByKey.set(newKey, best);
 
-    const doRecycle = () => {
-      try { ez.destroyPlaceholders(id); } catch (_) {}
-      setTimeout(() => {
-        mutate(() => {
-          best.setAttribute(ATTR.ANCHOR,  newKey);
-          best.setAttribute(ATTR.CREATED, String(now()));
-          best.setAttribute(ATTR.SHOWN,   '0');
-          best.classList.remove('is-empty');
-          best.replaceChildren();
-          const fresh = document.createElement('div');
-          fresh.id = `${PH_PREFIX}${id}`;
-          fresh.setAttribute('data-ezoic-id', String(id));
-          best.appendChild(fresh);
-          targetEl.insertAdjacentElement('afterend', best);
-        });
-        if (oldKey && S.wrapByKey.get(oldKey) === best) S.wrapByKey.delete(oldKey);
-        S.wrapByKey.set(newKey, best);
-        setTimeout(() => { observePh(id); enqueueShow(id); }, TIMING.RECYCLE_DELAY_MS);
-      }, TIMING.RECYCLE_DELAY_MS);
-    };
+    // Délais requis : destroyPlaceholders est asynchrone en interne
+    const doDestroy = () => { try { ez.destroyPlaceholders([id]); } catch (_) {} setTimeout(doDefine,  300); };
+    const doDefine  = () => { try { ez.define([id]);              } catch (_) {} setTimeout(doDisplay, 300); };
+    const doDisplay = () => { try { ez.displayMore([id]);         } catch (_) {} };
+    try { (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doDestroy) : doDestroy(); } catch (_) {}
 
-    try { (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doRecycle) : doRecycle(); } catch (_) {}
     return { id, wrap: best };
   }
 
-  // ── Wrap DOM operations ────────────────────────────────────────────────────
+  // ── Wraps DOM — création / suppression ────────────────────────────────────
 
   function makeWrap(id, klass, key) {
     const w = document.createElement('div');
     w.className = `${WRAP_CLASS} ${klass}`;
-    w.setAttribute(ATTR.ANCHOR,  key);
-    w.setAttribute(ATTR.WRAPID,  String(id));
-    w.setAttribute(ATTR.CREATED, String(now()));
-    w.setAttribute(ATTR.SHOWN,   '0');
-    w.style.cssText = 'width:100%;display:block';
+    w.setAttribute(A_ANCHOR,  key);
+    w.setAttribute(A_WRAPID,  String(id));
+    w.setAttribute(A_CREATED, String(ts()));
+    w.setAttribute(A_SHOWN,   '0');
+    w.style.cssText = 'width:100%;display:block;';
     const ph = document.createElement('div');
     ph.id = `${PH_PREFIX}${id}`;
     ph.setAttribute('data-ezoic-id', String(id));
@@ -367,15 +380,14 @@
   }
 
   function insertAfter(el, id, klass, key) {
-    if (!el?.insertAdjacentElement) return null;
-    if (findWrap(key)) return null;
-    if (S.mountedIds.has(id)) return null;
+    if (!el?.insertAdjacentElement)                                 return null;
+    if (findWrap(key))                                              return null;
+    if (S.mountedIds.has(id))                                       return null;
     if (document.getElementById(`${PH_PREFIX}${id}`)?.isConnected) return null;
     const w = makeWrap(id, klass, key);
     mutate(() => el.insertAdjacentElement('afterend', w));
     S.mountedIds.add(id);
     S.wrapByKey.set(key, w);
-    getWrapSet(klass).add(w);
     return w;
   }
 
@@ -383,58 +395,63 @@
     try {
       const ph = w.querySelector(`[id^="${PH_PREFIX}"]`);
       if (ph instanceof Element) S.io?.unobserve(ph);
-      const id = parseInt(w.getAttribute(ATTR.WRAPID), 10);
-      if (Number.isFinite(id)) {
-        S.mountedIds.delete(id);
-        S.lastShow.delete(id);
-      }
-      const key = w.getAttribute(ATTR.ANCHOR);
+      const id = parseInt(w.getAttribute(A_WRAPID), 10);
+      if (Number.isFinite(id)) S.mountedIds.delete(id);
+      const key = w.getAttribute(A_ANCHOR);
       if (key && S.wrapByKey.get(key) === w) S.wrapByKey.delete(key);
-      for (const cls of w.classList) {
-        if (cls !== WRAP_CLASS && cls.startsWith('ezoic-ad-')) {
-          S.wrapsByClass.get(cls)?.delete(w);
-          break;
-        }
-      }
       w.remove();
     } catch (_) {}
   }
 
-  // ── Prune (category topic lists only) ──────────────────────────────────────
+  // ── Prune (topics de catégorie uniquement) ────────────────────────────────
+  //
+  // Réactivé uniquement pour 'ezoic-ad-between' (liste de topics).
+  //
+  // Safe ici car NodeBB ne virtualise PAS les topics dans une catégorie :
+  //   les li[component="category/topic"] restent dans le DOM pendant toute
+  //   la session. Un wrap orphelin (ancre absente) signifie vraiment que le
+  //   topic a disparu. Sans ce nettoyage, les wraps s'accumulent en tête de
+  //   liste après un long scroll et bloquent les nouvelles injections.
+  //
+  // Toujours désactivé pour 'ezoic-ad-message' (posts de topic) :
+  //   NodeBB virtualise les posts hors-viewport — il les retire puis les
+  //   réinsère. pruneOrphans verrait des ancres temporairement absentes,
+  //   supprimerait les wraps, et provoquerait une réinjection en haut.
 
   function pruneOrphansBetween() {
     const klass = 'ezoic-ad-between';
     const cfg   = KIND[klass];
-    const wraps = S.wrapsByClass.get(klass);
-    if (!wraps?.size) return;
-    const liveAnchors = new Set();
-    for (const el of document.querySelectorAll(`${cfg.baseTag}[${cfg.anchorAttr}]`)) {
-      const v = el.getAttribute(cfg.anchorAttr);
-      if (v) liveAnchors.add(v);
-    }
-    const t = now();
-    for (const w of Array.from(wraps)) {
-      const created = parseInt(w.getAttribute(ATTR.CREATED) || '0', 10);
-      if (t - created < TIMING.MIN_PRUNE_AGE_MS) continue;
-      const key = w.getAttribute(ATTR.ANCHOR) ?? '';
-      const sid = key.slice(klass.length + 1);
-      if (!sid || !liveAnchors.has(sid)) mutate(() => dropWrap(w));
-    }
+
+    document.querySelectorAll(`.${WRAP_CLASS}.${klass}`).forEach(w => {
+      const created = parseInt(w.getAttribute(A_CREATED) || '0', 10);
+      if (ts() - created < MIN_PRUNE_AGE_MS) return; // grâce post-création
+
+      const key = w.getAttribute(A_ANCHOR) ?? '';
+      const sid = key.slice(klass.length + 1); // après "ezoic-ad-between:"
+      if (!sid) { mutate(() => dropWrap(w)); return; }
+
+      const anchorEl = document.querySelector(`${cfg.baseTag}[${cfg.anchorAttr}="${sid}"]`);
+      if (!anchorEl?.isConnected) mutate(() => dropWrap(w));
+    });
   }
 
   // ── Injection ──────────────────────────────────────────────────────────────
 
+  /**
+   * Ordinal 0-based pour le calcul de l'intervalle d'injection.
+   * Utilise ordinalAttr si défini, sinon compte les frères dans le parent.
+   */
   function ordinal(klass, el) {
     const attr = KIND[klass]?.ordinalAttr;
     if (attr) {
       const v = el.getAttribute(attr);
-      if (v != null && v !== '' && !isNaN(v)) return parseInt(v, 10);
+      if (v !== null && v !== '' && !isNaN(v)) return parseInt(v, 10);
     }
     const fullSel = KIND[klass]?.sel ?? '';
     let i = 0;
     for (const s of el.parentElement?.children ?? []) {
       if (s === el) return i;
-      try { if (!fullSel || s.matches(fullSel)) i++; } catch (_) {}
+      if (!fullSel || s.matches?.(fullSel)) i++;
     }
     return 0;
   }
@@ -442,27 +459,32 @@
   function injectBetween(klass, items, interval, showFirst, poolKey) {
     if (!items.length) return 0;
     let inserted = 0;
+
     for (const el of items) {
       if (inserted >= MAX_INSERTS_RUN) break;
       if (!el?.isConnected) continue;
+
       const ord = ordinal(klass, el);
       if (!(showFirst && ord === 0) && (ord + 1) % interval !== 0) continue;
       if (adjacentWrap(el)) continue;
+
       const key = anchorKey(klass, el);
       if (findWrap(key)) continue;
+
       const id = pickId(poolKey);
       if (id) {
         const w = insertAfter(el, id, klass, key);
         if (w) { observePh(id); inserted++; }
       } else {
-        if (!recycleWrap(klass, el, key)) break;
+        const recycled = recycleAndMove(klass, el, key);
+        if (!recycled) break;
         inserted++;
       }
     }
     return inserted;
   }
 
-  // ── IntersectionObserver ───────────────────────────────────────────────────
+  // ── IntersectionObserver & Show ────────────────────────────────────────────
 
   function getIO() {
     if (S.io) return S.io;
@@ -472,13 +494,9 @@
           if (!e.isIntersecting) continue;
           if (e.target instanceof Element) S.io?.unobserve(e.target);
           const id = parseInt(e.target.getAttribute('data-ezoic-id'), 10);
-          if (id > 0) enqueueShow(id);
+          if (Number.isFinite(id) && id > 0) enqueueShow(id);
         }
-      }, {
-        root: null,
-        rootMargin: isMobile() ? IO_MARGIN_MOBILE : IO_MARGIN_DESKTOP,
-        threshold: 0,
-      });
+      }, { root: null, rootMargin: isMobile() ? IO_MARGIN_MOBILE : IO_MARGIN_DESKTOP, threshold: 0 });
     } catch (_) { S.io = null; }
     return S.io;
   }
@@ -488,11 +506,9 @@
     if (ph?.isConnected) try { getIO()?.observe(ph); } catch (_) {}
   }
 
-  // ── Show queue ─────────────────────────────────────────────────────────────
-
   function enqueueShow(id) {
     if (!id || isBlocked()) return;
-    if (now() - (S.lastShow.get(id) ?? 0) < TIMING.SHOW_THROTTLE_MS) return;
+    if (ts() - (S.lastShow.get(id) ?? 0) < SHOW_THROTTLE_MS) return;
     if (S.inflight >= MAX_INFLIGHT) {
       if (!S.pendingSet.has(id)) { S.pending.push(id); S.pendingSet.add(id); }
       return;
@@ -519,26 +535,26 @@
       S.inflight = Math.max(0, S.inflight - 1);
       drainQueue();
     };
-    const timer = setTimeout(release, TIMING.SHOW_TIMEOUT_MS);
+    const timer = setTimeout(release, 7000);
 
     requestAnimationFrame(() => {
       try {
         if (isBlocked()) { clearTimeout(timer); return release(); }
         const ph = document.getElementById(`${PH_PREFIX}${id}`);
         if (!ph?.isConnected || isFilled(ph)) { clearTimeout(timer); return release(); }
-        const t = now();
-        if (t - (S.lastShow.get(id) ?? 0) < TIMING.SHOW_THROTTLE_MS) { clearTimeout(timer); return release(); }
+
+        const t = ts();
+        if (t - (S.lastShow.get(id) ?? 0) < SHOW_THROTTLE_MS) { clearTimeout(timer); return release(); }
         S.lastShow.set(id, t);
-        const wrap = ph.closest(`.${WRAP_CLASS}`);
-        try { wrap?.setAttribute(ATTR.SHOWN, String(t)); } catch (_) {}
+
+        try { ph.closest?.(`.${WRAP_CLASS}`)?.setAttribute(A_SHOWN, String(t)); } catch (_) {}
 
         window.ezstandalone = window.ezstandalone || {};
         const ez = window.ezstandalone;
         const doShow = () => {
           try { ez.showAds(id); } catch (_) {}
-          if (wrap) scheduleUncollapseChecks(wrap);
           scheduleEmptyCheck(id, t);
-          setTimeout(() => { clearTimeout(timer); release(); }, TIMING.SHOW_RELEASE_MS);
+          setTimeout(() => { clearTimeout(timer); release(); }, 700);
         };
         Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
       } catch (_) { clearTimeout(timer); release(); }
@@ -546,23 +562,22 @@
   }
 
   function scheduleEmptyCheck(id, showTs) {
-    for (const delay of [TIMING.EMPTY_CHECK_MS_1, TIMING.EMPTY_CHECK_MS_2]) {
-      setTimeout(() => {
-        try {
-          const ph   = document.getElementById(`${PH_PREFIX}${id}`);
-          const wrap = ph?.closest(`.${WRAP_CLASS}`);
-          if (!wrap || !ph?.isConnected) return;
-          if (parseInt(wrap.getAttribute(ATTR.SHOWN) || '0', 10) > showTs) return;
-          if (clearEmptyIfFilled(wrap)) return;
-          if (ph.querySelector('[id^="div-gpt-ad"]')) return;
-          if (ph.offsetHeight > 10) return;
-          wrap.classList.add('is-empty');
-        } catch (_) {}
-      }, delay);
-    }
+    setTimeout(() => {
+      try {
+        const ph   = document.getElementById(`${PH_PREFIX}${id}`);
+        const wrap = ph?.closest?.(`.${WRAP_CLASS}`);
+        if (!wrap || !ph?.isConnected) return;
+        if (parseInt(wrap.getAttribute(A_SHOWN) || '0', 10) > showTs) return;
+        wrap.classList.toggle('is-empty', !isFilled(ph));
+      } catch (_) {}
+    }, EMPTY_CHECK_MS);
   }
 
   // ── Patch Ezoic showAds ────────────────────────────────────────────────────
+  //
+  // Intercepte ez.showAds() pour :
+  //   – ignorer les appels pendant blockedUntil
+  //   – filtrer les ids dont le placeholder n'est pas en DOM
 
   function patchShowAds() {
     const apply = () => {
@@ -573,9 +588,8 @@
         window.__nbbEzPatched = true;
         const orig = ez.showAds.bind(ez);
         ez.showAds = function (...args) {
-          if (!args.length) return orig();
           if (isBlocked()) return;
-          const ids = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+          const ids  = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
           const seen = new Set();
           for (const v of ids) {
             const id = parseInt(v, 10);
@@ -599,7 +613,6 @@
   async function runCore() {
     if (isBlocked()) return 0;
     patchShowAds();
-    try { gcDisconnectedWraps(); } catch (_) {}
 
     const cfg = await fetchConfig();
     if (!cfg || cfg.excluded) return 0;
@@ -610,16 +623,27 @@
 
     const exec = (klass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
       if (!normBool(cfgEnable)) return 0;
-      return injectBetween(klass, getItems(), Math.max(1, parseInt(cfgInterval, 10) || 3), normBool(cfgShowFirst), poolKey);
+      const interval = Math.max(1, parseInt(cfgInterval, 10) || 3);
+      return injectBetween(klass, getItems(), interval, normBool(cfgShowFirst), poolKey);
     };
 
-    if (kind === 'topic')
-      return exec('ezoic-ad-message', getPosts, cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts');
+    if (kind === 'topic') return exec(
+      'ezoic-ad-message', getPosts,
+      cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts'
+    );
+
     if (kind === 'categoryTopics') {
       pruneOrphansBetween();
-      return exec('ezoic-ad-between', getTopics, cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics');
+      return exec(
+        'ezoic-ad-between', getTopics,
+        cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics'
+      );
     }
-    return exec('ezoic-ad-categories', getCategories, cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories');
+
+    return exec(
+      'ezoic-ad-categories', getCategories,
+      cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories'
+    );
   }
 
   // ── Scheduler ──────────────────────────────────────────────────────────────
@@ -638,16 +662,18 @@
 
   function requestBurst() {
     if (isBlocked()) return;
-    const t = now();
-    if (t - S.lastBurstTs < TIMING.BURST_COOLDOWN_MS) return;
+    const t = ts();
+    if (t - S.lastBurstTs < BURST_COOLDOWN_MS) return;
     S.lastBurstTs   = t;
     S.pageKey       = pageKey();
-    S.burstDeadline = t + BURST_WINDOW_MS;
+    S.burstDeadline = t + 2000;
+
     if (S.burstActive) return;
     S.burstActive = true;
     S.burstCount  = 0;
+
     const step = () => {
-      if (pageKey() !== S.pageKey || isBlocked() || now() > S.burstDeadline || S.burstCount >= MAX_BURST_STEPS) {
+      if (pageKey() !== S.pageKey || isBlocked() || ts() > S.burstDeadline || S.burstCount >= 8) {
         S.burstActive = false; return;
       }
       S.burstCount++;
@@ -659,163 +685,88 @@
     step();
   }
 
-  // ── Cleanup ────────────────────────────────────────────────────────────────
+  // ── Cleanup navigation ─────────────────────────────────────────────────────
 
   function cleanup() {
-    S.blockedUntil = now() + TIMING.BLOCK_DURATION_MS;
-    mutate(() => {
-      for (const w of document.querySelectorAll(`.${WRAP_CLASS}`)) dropWrap(w);
-    });
-    S.cfg        = null;
-    S.poolsReady = false;
-    S.pools      = { topics: [], posts: [], categories: [] };
-    S.cursors    = { topics: 0, posts: 0, categories: 0 };
+    blockedUntil = ts() + 1500;
+    mutate(() => document.querySelectorAll(`.${WRAP_CLASS}`).forEach(dropWrap));
+    S.cfg          = null;
+    S.poolsReady   = false;
+    S.pools        = { topics: [], posts: [], categories: [] };
+    S.cursors      = { topics: 0, posts: 0, categories: 0 };
     S.mountedIds.clear();
     S.lastShow.clear();
     S.wrapByKey.clear();
-    S.wrapsByClass.clear();
-    S.kind       = null;
-    S.inflight   = 0;
-    S.pending    = [];
+    S.inflight     = 0;
+    S.pending      = [];
     S.pendingSet.clear();
-    S.burstActive = false;
-    S.runQueued   = false;
+    S.burstActive  = false;
+    S.runQueued    = false;
   }
 
   // ── MutationObserver ───────────────────────────────────────────────────────
 
   function ensureDomObserver() {
     if (S.domObs) return;
+    const allSel = [SEL.post, SEL.topic, SEL.category];
     S.domObs = new MutationObserver(muts => {
       if (S.mutGuard > 0 || isBlocked()) return;
-      let needsBurst = false;
-      const kind = getKind();
-      const relevantSels =
-        kind === 'topic'          ? [SEL.post]     :
-        kind === 'categoryTopics' ? [SEL.topic]    :
-        kind === 'categories'     ? [SEL.category] :
-                                    [SEL.post, SEL.topic, SEL.category];
-      outer:
       for (const m of muts) {
-        if (m.type !== 'childList') continue;
-        for (const node of m.removedNodes) {
-          if (!(node instanceof Element)) continue;
-          try {
-            if (node.classList?.contains(WRAP_CLASS)) dropWrap(node);
-            else { const ws = node.querySelectorAll?.(`.${WRAP_CLASS}`); if (ws?.length) for (const w of ws) dropWrap(w); }
-          } catch (_) {}
-        }
-        for (const node of m.addedNodes) {
-          if (!(node instanceof Element)) continue;
-          try {
-            if (node.matches?.(FILL_SEL) || node.querySelector?.(FILL_SEL)) {
-              const wrap = node.closest?.(`.${WRAP_CLASS}.is-empty`) || m.target?.closest?.(`.${WRAP_CLASS}.is-empty`);
-              if (wrap) clearEmptyIfFilled(wrap);
-            }
-          } catch (_) {}
-          try {
-            const reinserted = node.classList?.contains(WRAP_CLASS) ? [node] : Array.from(node.querySelectorAll?.(`.${WRAP_CLASS}`) || []);
-            for (const wrap of reinserted) {
-              const id = parseInt(wrap.getAttribute(ATTR.WRAPID), 10);
-              if (id > 0) { const ph = wrap.querySelector(`[id^="${PH_PREFIX}"]`); if (ph) try { getIO()?.observe(ph); } catch (_) {} }
-            }
-          } catch (_) {}
-          if (!needsBurst) {
-            for (const sel of relevantSels) {
-              try { if (node.matches(sel) || node.querySelector(sel)) { needsBurst = true; break outer; } } catch (_) {}
-            }
+        for (const n of m.addedNodes) {
+          if (n.nodeType !== 1) continue;
+          // matches() d'abord (O(1)), querySelector() seulement si nécessaire
+          if (allSel.some(s => { try { return n.matches(s); } catch(_){return false;} }) ||
+              allSel.some(s => { try { return !!n.querySelector(s); } catch(_){return false;} })) {
+            requestBurst(); return;
           }
         }
       }
-      if (needsBurst) requestBurst();
     });
     try { S.domObs.observe(document.body, { childList: true, subtree: true }); } catch (_) {}
   }
 
-  // ── TCF / CMP Protection ───────────────────────────────────────────────────
-
-  function ensureTcfLocator() {
-    if (!window.__tcfapi && !window.__cmp) return;
-    const LOCATOR_ID = '__tcfapiLocator';
-    const ensureInHead = () => {
-      let el = document.getElementById(LOCATOR_ID);
-      if (el) { if (el.parentElement !== document.head) try { document.head.appendChild(el); } catch (_) {} return; }
-      const f = document.createElement('iframe');
-      f.style.display = 'none'; f.id = f.name = LOCATOR_ID;
-      try { document.head.appendChild(f); } catch (_) { (document.body || document.documentElement).appendChild(f); }
-    };
-    ensureInHead();
-    if (!window.__nbbCmpGuarded) {
-      window.__nbbCmpGuarded = true;
-      if (typeof window.__tcfapi === 'function') {
-        const orig = window.__tcfapi;
-        window.__tcfapi = function (cmd, ver, cb, param) {
-          try { return orig.call(this, cmd, ver, function (...a) { try { cb?.(...a); } catch (_) {} }, param); }
-          catch (e) { if (e?.message?.includes('null')) { ensureInHead(); try { return orig.call(this, cmd, ver, cb, param); } catch (_) {} } }
-        };
-      }
-      if (typeof window.__cmp === 'function') {
-        const orig = window.__cmp;
-        window.__cmp = function (...a) {
-          try { return orig.apply(this, a); }
-          catch (e) { if (e?.message?.includes('null')) { ensureInHead(); try { return orig.apply(this, a); } catch (_) {} } }
-        };
-      }
-    }
-    if (!window.__nbbTcfObs) {
-      window.__nbbTcfObs = new MutationObserver(() => { if (!document.getElementById(LOCATOR_ID)) ensureInHead(); });
-      try { window.__nbbTcfObs.observe(document.body || document.documentElement, { childList: true, subtree: false }); } catch (_) {}
-      try { if (document.head) window.__nbbTcfObs.observe(document.head, { childList: true, subtree: false }); } catch (_) {}
-    }
-  }
-
-  // ── aria-hidden protection ─────────────────────────────────────────────────
-
-  function protectAriaHidden() {
-    if (window.__nbbAriaObs) return;
-    const fix = () => { try { if (document.body.getAttribute('aria-hidden') === 'true') document.body.removeAttribute('aria-hidden'); } catch (_) {} };
-    fix();
-    window.__nbbAriaObs = new MutationObserver(fix);
-    try { window.__nbbAriaObs.observe(document.body, { attributes: true, attributeFilter: ['aria-hidden'] }); } catch (_) {}
-  }
-
-  // ── Console muting ─────────────────────────────────────────────────────────
+  // ── Utilitaires ────────────────────────────────────────────────────────────
 
   function muteConsole() {
     if (window.__nbbEzMuted) return;
     window.__nbbEzMuted = true;
     const MUTED = [
+      '[EzoicAds JS]: Placeholder Id',
+      'No valid placeholders for loadMore',
+      'cannot call refresh on the same page',
+      'no placeholders are currently defined in Refresh',
+      'Debugger iframe already exists',
       `with id ${PH_PREFIX}`,
-      'adsbygoogle.push() error',
-      'already been defined',
-      'bad response. Status',
-      'slotDestroyed',
-      'identity bridging',
-      '[EzoicAds JS]: Placeholder',
-      'No valid placeholders',
-      'cannot call refresh',
-      'no placeholders are currently defined',
-      'Debugger iframe already',
-      'Error in custom getTCData',
-      'no interstitial API',
-      'JS-Enable should only',
     ];
-    for (const method of ['log', 'info', 'warn', 'error']) {
-      const orig = console[method];
+    for (const m of ['log', 'info', 'warn', 'error']) {
+      const orig = console[m];
       if (typeof orig !== 'function') continue;
-      console[method] = function (...args) {
-        if (typeof args[0] === 'string') { for (const p of MUTED) if (args[0].includes(p)) return; }
-        return orig.apply(console, args);
+      console[m] = function (...a) {
+        if (typeof a[0] === 'string' && MUTED.some(p => a[0].includes(p))) return;
+        orig.apply(console, a);
       };
     }
   }
 
-  // ── Network warmup ─────────────────────────────────────────────────────────
+  function ensureTcfLocator() {
+    try {
+      if (!window.__tcfapi && !window.__cmp) return;
+      const inject = () => {
+        if (document.getElementById('__tcfapiLocator')) return;
+        const f = document.createElement('iframe');
+        f.style.display = 'none'; f.id = f.name = '__tcfapiLocator';
+        (document.body || document.documentElement).appendChild(f);
+      };
+      inject();
+      if (!window.__nbbTcfObs) {
+        window.__nbbTcfObs = new MutationObserver(inject);
+        window.__nbbTcfObs.observe(document.documentElement, { childList: true, subtree: true });
+      }
+    } catch (_) {}
+  }
 
-  let _warmed = false;
+  const _warmed = new Set();
   function warmNetwork() {
-    if (_warmed) return;
-    _warmed = true;
     const head = document.head;
     if (!head) return;
     for (const [rel, href, cors] of [
@@ -826,7 +777,9 @@
       ['dns-prefetch', 'https://g.ezoic.net',                    false],
       ['dns-prefetch', 'https://securepubads.g.doubleclick.net', false],
     ]) {
-      if (head.querySelector(`link[rel="${rel}"][href="${href}"]`)) continue;
+      const k = `${rel}|${href}`;
+      if (_warmed.has(k)) continue;
+      _warmed.add(k);
       const l = document.createElement('link');
       l.rel = rel; l.href = href;
       if (cors) l.crossOrigin = 'anonymous';
@@ -839,25 +792,29 @@
   function bindNodeBB() {
     const $ = window.jQuery;
     if (!$) return;
+
     $(window).off('.nbbEzoic');
     $(window).on('action:ajaxify.start.nbbEzoic', cleanup);
     $(window).on('action:ajaxify.end.nbbEzoic', () => {
-      S.pageKey = pageKey(); S.kind = null; S.blockedUntil = 0;
-      muteConsole(); ensureTcfLocator(); protectAriaHidden();
-      warmNetwork(); patchShowAds(); getIO(); ensureDomObserver();
-      requestBurst();
+      S.pageKey    = pageKey();
+      blockedUntil = 0;
+      muteConsole(); ensureTcfLocator(); warmNetwork();
+      patchShowAds(); getIO(); ensureDomObserver(); requestBurst();
     });
+
     const burstEvts = [
-      'action:ajaxify.contentLoaded', 'action:posts.loaded',
-      'action:topics.loaded', 'action:categories.loaded',
-      'action:category.loaded', 'action:topic.loaded',
+      'action:ajaxify.contentLoaded', 'action:posts.loaded', 'action:topics.loaded',
+      'action:categories.loaded', 'action:category.loaded', 'action:topic.loaded',
     ].map(e => `${e}.nbbEzoic`).join(' ');
     $(window).on(burstEvts, () => { if (!isBlocked()) requestBurst(); });
+
     try {
       require(['hooks'], hooks => {
         if (typeof hooks?.on !== 'function') return;
-        for (const ev of ['action:ajaxify.end', 'action:posts.loaded', 'action:topics.loaded', 'action:categories.loaded', 'action:topic.loaded'])
+        for (const ev of ['action:ajaxify.end', 'action:posts.loaded', 'action:topics.loaded',
+                          'action:categories.loaded', 'action:topic.loaded']) {
           try { hooks.on(ev, () => { if (!isBlocked()) requestBurst(); }); } catch (_) {}
+        }
       });
     } catch (_) {}
   }
@@ -865,7 +822,8 @@
   function bindScroll() {
     let ticking = false;
     window.addEventListener('scroll', () => {
-      if (ticking) return; ticking = true;
+      if (ticking) return;
+      ticking = true;
       requestAnimationFrame(() => { ticking = false; requestBurst(); });
     }, { passive: true });
   }
@@ -875,30 +833,13 @@
   S.pageKey = pageKey();
   muteConsole();
   ensureTcfLocator();
-  protectAriaHidden();
   warmNetwork();
   patchShowAds();
   getIO();
   ensureDomObserver();
   bindNodeBB();
   bindScroll();
-  S.blockedUntil = 0;
+  blockedUntil = 0;
   requestBurst();
 
-  // Retry boot: sa.min.js async + Cloudflare Rocket Loader + NodeBB SPA
-  // can cause client.js to boot before DOM/Ezoic are ready.
-  // Retries stop once ads are mounted or after ~10s.
-  let _retries = 0;
-  function retryBoot() {
-    if (_retries >= 12 || S.mountedIds.size > 0) return;
-    _retries++;
-    patchShowAds();
-    if (!isBlocked() && !S.burstActive) {
-      S.lastBurstTs = 0;
-      requestBurst();
-    }
-    setTimeout(retryBoot, _retries <= 4 ? 300 : 1000);
-  }
-  setTimeout(retryBoot, 250);
-
 })();