nodebb-plugin-ezoic-infinite 1.8.22 → 1.8.24

package/public/client.js

@@ -1,83 +1,192 @@
-(function nbbEzoicInfiniteV22() {
+/**
+ * NodeBB Ezoic Infinite Ads — client.js v36
+ *
+ * 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';
 
-  const WRAP_CLASS = 'nodebb-ezoic-wrap';
-  const PH_PREFIX = 'ezoic-pub-ad-placeholder-';
-  const A_ANCHOR = 'data-ezoic-anchor';
-  const A_WRAPID = 'data-ezoic-wrapid';
-  const A_CREATED = 'data-ezoic-created';
-  const A_SHOWN = 'data-ezoic-shown';
-  const A_STATE = 'data-ezoic-state';
+  // ── Constantes ─────────────────────────────────────────────────────────────
+
+  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 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
+  const MIN_PLACEHOLDER_HEIGHT = 50; // réservation minimale perçue
+
+  // 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';
 
   const SEL = {
-    post: '[component="post"][data-pid]',
-    topic: 'li[component="category/topic"]',
+    post:     '[component="post"][data-pid]',
+    topic:    'li[component="category/topic"]',
     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', pool: 'posts' },
-    'ezoic-ad-between':    { sel: SEL.topic,    baseTag: 'li', anchorAttr: 'data-index', ordinalAttr: 'data-index', pool: 'topics' },
-    'ezoic-ad-categories': { sel: SEL.category, baseTag: 'li', anchorAttr: 'data-cid',   ordinalAttr: null,         pool: 'categories' },
+    '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 CFG = {
-    maxInsertsPerRun: 8,
-    maxShowInflight: 1,
-    maxShowBatch: 1,
-    showThrottleMs: 1500,
-    showCooldownMs: 15000,
-    showReleaseMs: 350,
-    showFailsafeMs: 8000,
-    batchFlushMs: 80,
-    runDebounceMs: 80,
-    orphanGraceMs: 12000,
-    retireGraceMs: 25000,
-    recentActivityMs: 6000,
-    viewportBufferDesktop: 700,
-    viewportBufferMobile: 350,
-    ioMarginDesktop: '1800px 0px 2200px 0px',
-    ioMarginMobile: '2400px 0px 2800px 0px',
-    maintenanceEveryMs: 1200,
-    minHeightRememberMin: 40,
-  };
+  // ── État global ────────────────────────────────────────────────────────────
 
   const S = {
-    cfg: null,
-    poolsReady: false,
-    pools: { topics: [], posts: [], categories: [] },
-    cursors: { topics: 0, posts: 0, categories: 0 },
-    pageKey: null,
-    blockedUntil: 0,
-    runTimer: 0,
-    maintenanceTimer: 0,
-    io: null,
-    domObs: null,
-    muting: 0,
-    mountedIds: new Set(),
-    wrapByKey: new Map(),
-    regById: new Map(),
-    lastShowById: new Map(),
-    lastWrapHeightByClass: new Map(),
-    pendingShow: [],
-    pendingSet: new Set(),
-    showTimer: 0,
-    inflightShow: 0,
+    pageKey:      null,
+    cfg:          null,
+    poolsReady:   false,
+    pools:        { topics: [], posts: [], categories: [] },
+    cursors:      { topics: 0,  posts: 0,  categories: 0  },
+    mountedIds:   new Set(),
+    lastShow:     new Map(),
+    io:           null,
+    domObs:       null,
+    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,
+    burstCount:   0,
+    lastBurstTs:  0,
+    firstShown:   false,
+    wrapsByClass: new Map(),
+    kind:         null,
   };
 
-  const now = () => Date.now();
-  const isBlocked = () => now() < S.blockedUntil;
-  const isMobile = () => {
-    try { return window.innerWidth < 768; } catch (_) { return false; }
-  };
-  const viewportBuffer = () => (isMobile() ? CFG.viewportBufferMobile : CFG.viewportBufferDesktop);
-  const normBool = v => v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
+  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.muting++;
-    try { return fn(); } finally { S.muting = Math.max(0, S.muting - 1); }
+    S.mutGuard++;
+    try { fn(); } finally { S.mutGuard--; }
   }
 
+  // ── Config ─────────────────────────────────────────────────────────────────
+
+  async function fetchConfig() {
+    if (S.cfg) return S.cfg;
+    try {
+      if (window.__nbbEzoicCfg && typeof window.__nbbEzoicCfg === 'object') {
+        S.cfg = window.__nbbEzoicCfg;
+        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();
+    } catch (_) {}
+    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);
+    S.pools.posts      = parseIds(cfg.messagePlaceholderIds);
+    S.pools.categories = parseIds(cfg.categoryPlaceholderIds);
+    S.poolsReady = true;
+  }
+
+  // ── Page identity ──────────────────────────────────────────────────────────
+
   function pageKey() {
     try {
       const d = window.ajaxify?.data;
@@ -87,718 +196,668 @@
     return location.pathname;
   }
 
-  function getKind() {
+  function detectKind() {
     const p = location.pathname;
-    if (/^\/topic\//.test(p)) return 'topic';
-    if (/^\/category\//.test(p)) return 'categoryTopics';
+    if (/^\/topic\//.test(p))                 return 'topic';
+    if (/^\/category\//.test(p))              return 'categoryTopics';
     if (p === '/' || /^\/categories/.test(p)) return 'categories';
-    if (document.querySelector(SEL.post)) return 'topic';
-    if (document.querySelector(SEL.topic)) return 'categoryTopics';
     if (document.querySelector(SEL.category)) return 'categories';
+    if (document.querySelector(SEL.post))     return 'topic';
+    if (document.querySelector(SEL.topic))    return 'categoryTopics';
     return 'other';
   }
 
+  function getKind() {
+    if (S.kind) return S.kind;
+    S.kind = detectKind();
+    return S.kind;
+  }
+
+  // ── Items DOM ──────────────────────────────────────────────────────────────
+
   function getPosts() {
     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);
+      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));
-
-  async function fetchConfig() {
-    if (S.cfg) return S.cfg;
-    try {
-      const r = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
-      if (r.ok) S.cfg = await r.json();
-    } catch (_) {}
-    return S.cfg;
-  }
 
-  function parseIds(raw) {
-    const out = [];
-    const seen = new Set();
-    for (const line of String(raw || '').split(/\r?\n/)) {
-      const n = parseInt(line.trim(), 10);
-      if (n > 0 && Number.isFinite(n) && !seen.has(n)) { seen.add(n); out.push(n); }
-    }
-    return out;
-  }
+  const getTopics     = () => Array.from(document.querySelectorAll(SEL.topic));
+  const getCategories = () => Array.from(document.querySelectorAll(SEL.category));
 
-  function initPools(cfg) {
-    if (S.poolsReady) return;
-    S.pools = {
-      topics: parseIds(cfg.placeholderIds),
-      posts: parseIds(cfg.messagePlaceholderIds),
-      categories: parseIds(cfg.categoryPlaceholderIds),
-    };
-    S.poolsReady = true;
-  }
+  // ── Wraps — détection ──────────────────────────────────────────────────────
 
-  function textSig(el) {
-    if (!(el instanceof Element)) return '';
-    const parts = [el.id || '', String(el.className || ''), el.getAttribute('name') || ''];
-    for (const a of ['data-slot', 'data-ad-slot', 'data-google-container-id']) {
-      try { const v = el.getAttribute(a); if (v) parts.push(v); } catch (_) {}
+  /**
+   * 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(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) {
+      for (const sib of parent.children) {
+        if (sib === wrap) continue;
+        try {
+          if (sib.matches(`${cfg.baseTag || ''}[${cfg.anchorAttr}="${anchorId}"]`)) {
+            return sib.isConnected;
+          }
+        } catch (_) {}
+      }
     }
-    return parts.join(' ').toLowerCase();
-  }
-
-  function isSpecialLike(root) {
-    if (!(root instanceof Element)) return false;
-    const test = el => /adhesion|interstitial|anchor|sticky|outofpage/.test(textSig(el));
-    if (test(root)) return true;
+    // Dernier recours : querySelector global
     try {
-      const nodes = root.querySelectorAll('[id],[class],[name],[data-slot],[data-ad-slot]');
-      for (const n of nodes) if (test(n)) return true;
-    } catch (_) {}
-    return false;
-  }
-
-  function hasFixedLike(root, max = 16) {
-    if (!(root instanceof Element)) return false;
-    const q = [root];
-    let seen = 0;
-    while (q.length && seen < max) {
-      const n = q.shift();
-      seen++;
-      try {
-        const cs = window.getComputedStyle(n);
-        if (cs.position === 'fixed' || cs.position === 'sticky') return true;
-      } catch (_) {}
-      for (const c of n.children || []) q.push(c);
-    }
-    return false;
+      const found = document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`);
+      return !!(found?.isConnected);
+    } catch (_) { return false; }
   }
 
-  function isFilled(wrap) {
-    try { return !!wrap?.querySelector?.('iframe, ins, img, video, [data-google-container-id]'); } catch (_) { return false; }
+  function adjacentWrap(el) {
+    return wrapIsLive(el.nextElementSibling) || wrapIsLive(el.previousElementSibling);
   }
 
-  function phEl(id) { return document.getElementById(`${PH_PREFIX}${id}`); }
+  // ── Ancres stables ─────────────────────────────────────────────────────────
 
-  function anchorStableId(klass, el) {
+  /**
+   * 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++; }
+    for (const s of el.parentElement?.children ?? []) {
+      if (s === el) return `i${i}`;
+      i++;
+    }
     return 'i0';
   }
-  const anchorKey = (klass, el) => `${klass}:${anchorStableId(klass, el)}`;
 
-  function findWrapByKey(key) {
+  const anchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
+
+  function findWrap(key) {
     const w = S.wrapByKey.get(key);
     return (w?.isConnected) ? w : null;
   }
 
-  function rememberWrapHeight(wrap) {
-    try {
-      if (!(wrap instanceof Element)) return;
-      const klass = [...(wrap.classList || [])].find(c => c.startsWith('ezoic-ad-'));
-      if (!klass) return;
-      const h = Math.round(wrap.getBoundingClientRect().height || 0);
-      if (h >= CFG.minHeightRememberMin) S.lastWrapHeightByClass.set(klass, h);
-    } catch (_) {}
+  function wrapsSet(klass) {
+    let set = S.wrapsByClass.get(klass);
+    if (!set) { set = new Set(); S.wrapsByClass.set(klass, set); }
+    return set;
   }
+  const registerWrap = (klass, w) => wrapsSet(klass).add(w);
+  const unregisterWrap = (klass, w) => S.wrapsByClass.get(klass)?.delete(w);
 
-  function wrapNearViewport(wrap) {
-    try {
-      const r = wrap.getBoundingClientRect();
-      const b = viewportBuffer();
-      const vh = window.innerHeight || 800;
-      return r.bottom > -b && r.top < vh + b;
-    } catch (_) { return true; }
-  }
-
-  function ensureRegistry(id, wrap) {
-    let rec = S.regById.get(id);
-    if (!rec) {
-      rec = {
-        id,
-        wrap,
-        key: wrap?.getAttribute(A_ANCHOR) || '',
-        state: 'idle',
-        typeClass: [...(wrap?.classList || [])].find(c => c.startsWith('ezoic-ad-')) || '',
-        isSpecial: false,
-        isFixedLike: false,
-        createdAt: now(),
-        shownAt: 0,
-        lastSeenAt: 0,
-        lastMutationAt: now(),
-        cooldownUntil: 0,
-      };
-      S.regById.set(id, rec);
-    }
-    if (wrap && rec.wrap !== wrap) rec.wrap = wrap;
-    if (wrap) {
-      rec.key = wrap.getAttribute(A_ANCHOR) || rec.key;
-      rec.typeClass = [...(wrap.classList || [])].find(c => c.startsWith('ezoic-ad-')) || rec.typeClass;
-    }
-    return rec;
-  }
-
-  function updateWrapState(rec, state) {
-    rec.state = state;
-    try { rec.wrap?.setAttribute?.(A_STATE, state); } catch (_) {}
-  }
+  // ── 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] || [];
+    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;
   }
 
+  /**
+   * 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?.define             !== 'function' ||
+        typeof ez?.displayMore        !== 'function') 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 (S.wrapsByClass.get(klass) || [])) {
+      try {
+        const rect = wrap.getBoundingClientRect();
+        if (rect.bottom > threshold) return;
+        if (!isFilled(wrap)) {
+          if (rect.bottom < bestEmptyBottom) { bestEmptyBottom = rect.bottom; bestEmpty = wrap; }
+        } else {
+          if (rect.bottom < bestFilledBottom) { bestFilledBottom = rect.bottom; bestFilled = wrap; }
+        }
+      } catch (_) {}
+    }
+
+    const best = bestEmpty ?? bestFilled;
+    if (!best) return null;
+    const id = parseInt(best.getAttribute(A_WRAPID), 10);
+    if (!Number.isFinite(id)) return null;
+
+    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) ph.innerHTML = '';
+      targetEl.insertAdjacentElement('afterend', best);
+    });
+    if (oldKey && S.wrapByKey.get(oldKey) === best) S.wrapByKey.delete(oldKey);
+    S.wrapByKey.set(newKey, best);
+
+    // 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 (_) {}
+
+    return { id, wrap: best };
+  }
+
+  // ── Wraps DOM — création / suppression ────────────────────────────────────
+
   function makeWrap(id, klass, key) {
     const w = document.createElement('div');
     w.className = `${WRAP_CLASS} ${klass}`;
-    w.setAttribute(A_ANCHOR, key);
-    w.setAttribute(A_WRAPID, String(id));
-    w.setAttribute(A_CREATED, String(now()));
-    w.setAttribute(A_SHOWN, '0');
-    w.setAttribute(A_STATE, 'idle');
-    w.style.cssText = 'display:block;width:100%;';
-    const h = S.lastWrapHeightByClass.get(klass);
-    if (Number.isFinite(h) && h > 0) w.style.minHeight = `${h}px`;
+    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));
+    ph.style.minHeight = `${MIN_PLACEHOLDER_HEIGHT}px`;
     w.appendChild(ph);
     return w;
   }
 
-  function insertWrapAfter(anchorEl, id, klass, key) {
-    if (!anchorEl?.insertAdjacentElement) return null;
-    if (findWrapByKey(key)) return null;
-    if (S.mountedIds.has(id)) return null;
-    if (phEl(id)?.isConnected) return null;
+  function insertAfter(el, id, klass, key) {
+    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(() => anchorEl.insertAdjacentElement('afterend', w));
+    mutate(() => el.insertAdjacentElement('afterend', w));
     S.mountedIds.add(id);
     S.wrapByKey.set(key, w);
-    const rec = ensureRegistry(id, w);
-    rec.key = key;
-    rec.createdAt = now();
-    rec.lastMutationAt = now();
-    rec.isSpecial = false;
-    rec.isFixedLike = false;
-    updateWrapState(rec, 'idle');
-    observePlaceholder(id);
+    registerWrap(klass, w);
     return w;
   }
 
-  function releaseWrap(wrap) {
+  function dropWrap(w) {
     try {
-      rememberWrapHeight(wrap);
-      const id = parseInt(wrap.getAttribute(A_WRAPID), 10);
-      const key = wrap.getAttribute(A_ANCHOR) || '';
-      const ph = wrap.querySelector(`[id^="${PH_PREFIX}"]`);
-      if (ph) try { S.io?.unobserve(ph); } catch (_) {}
-      if (key && S.wrapByKey.get(key) === wrap) S.wrapByKey.delete(key);
-      if (Number.isFinite(id)) {
-        S.mountedIds.delete(id);
-        S.pendingSet.delete(id);
-        S.lastShowById.delete(id);
-        const rec = S.regById.get(id);
-        if (rec) {
-          rec.wrap = null;
-          rec.state = 'retired';
-          rec.cooldownUntil = Math.max(rec.cooldownUntil || 0, now() + 3000);
-        }
-      }
-      wrap.remove();
+      const ph = w.querySelector(`[id^="${PH_PREFIX}"]`);
+      if (ph instanceof Element) S.io?.unobserve(ph);
+      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);
+      const klass = Array.from(w.classList || []).find(c => c !== WRAP_CLASS && c.startsWith('ezoic-ad-'));
+      if (klass) unregisterWrap(klass, w);
+      w.remove();
     } catch (_) {}
   }
 
-  function wrapHasAnchor(wrap) {
-    const key = wrap?.getAttribute?.(A_ANCHOR);
-    if (!key) return false;
-    const i = key.indexOf(':');
-    const klass = key.slice(0, i);
-    const sid = key.slice(i + 1);
-    const def = KIND[klass];
-    if (!def) return false;
-    try {
-      const sel = `${def.sel}[${def.anchorAttr}="${sid}"]`;
-      return !!document.querySelector(sel);
-    } catch (_) { return false; }
-  }
-
-  function sweepDisconnected() {
-    for (const [key, wrap] of [...S.wrapByKey.entries()]) {
-      if (wrap?.isConnected) continue;
-      S.wrapByKey.delete(key);
-      const id = parseInt(wrap?.getAttribute?.(A_WRAPID), 10);
-      if (Number.isFinite(id)) {
-        S.mountedIds.delete(id);
-        S.pendingSet.delete(id);
-      }
-    }
-  }
-
-  function classifyWrap(rec) {
-    const w = rec.wrap;
-    if (!w?.isConnected) return;
-    if (!rec.isSpecial) rec.isSpecial = isSpecialLike(w);
-    if (!rec.isFixedLike) rec.isFixedLike = hasFixedLike(w);
-  }
-
-  function maintenance() {
-    if (isBlocked()) return;
-    sweepDisconnected();
-    const t = now();
-    for (const [id, rec] of S.regById) {
-      const w = rec.wrap;
-      if (!w?.isConnected) continue;
-      classifyWrap(rec);
-      if (wrapNearViewport(w)) {
-        rec.lastSeenAt = t;
-        if (rec.state === 'retiring') updateWrapState(rec, 'live');
-        continue;
-      }
-      const created = parseInt(w.getAttribute(A_CREATED) || '0', 10) || rec.createdAt || 0;
-      const shown = parseInt(w.getAttribute(A_SHOWN) || '0', 10) || rec.shownAt || 0;
-      const age = t - Math.max(created, shown || 0, rec.lastMutationAt || 0);
-      const activeRecently = (t - (rec.lastMutationAt || 0)) < CFG.recentActivityMs;
-      const filled = isFilled(w);
-      if (filled) { rec.lastMutationAt = t; rec.shownAt = Math.max(rec.shownAt || 0, shown || 0); }
-      if (rec.isSpecial || rec.isFixedLike) continue; // never retire plugin-side
-      if (activeRecently) continue;
-      if (filled) continue; // keep rendered slots stable; no aggressive destroy/recycle
-      if (age < CFG.retireGraceMs) continue;
-      if (rec.state !== 'retiring') {
-        updateWrapState(rec, 'retiring');
-        continue;
-      }
-      // second pass confirmation
-      if (wrapNearViewport(w) || isFilled(w)) { updateWrapState(rec, 'live'); continue; }
-      releaseWrap(w);
+  // ── 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 liveAnchors = new Set(Array.from(document.querySelectorAll(`${cfg.baseTag}[${cfg.anchorAttr}]`))
+      .map(el => el.getAttribute(cfg.anchorAttr)).filter(Boolean));
+
+    for (const w of (S.wrapsByClass.get(klass) || [])) {
+      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; }
+
+      if (!liveAnchors.has(sid)) mutate(() => dropWrap(w));
     }
   }
 
-  function scheduleMaintenance() {
-    if (S.maintenanceTimer) return;
-    S.maintenanceTimer = setTimeout(() => {
-      S.maintenanceTimer = 0;
-      maintenance();
-    }, CFG.maintenanceEveryMs);
-  }
+  // ── 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);
     }
+    const fullSel = KIND[klass]?.sel ?? '';
     let i = 0;
-    const fullSel = KIND[klass]?.sel || '';
-    for (const s of el.parentElement?.children || []) {
+    for (const s of el.parentElement?.children ?? []) {
       if (s === el) return i;
       if (!fullSel || s.matches?.(fullSel)) i++;
     }
     return 0;
   }
 
-  function adjacentManagedWrap(el) {
-    const isManaged = n => !!(n?.classList?.contains(WRAP_CLASS) && n.isConnected);
-    return isManaged(el.nextElementSibling) || isManaged(el.previousElementSibling);
-  }
-
-  function injectFor(klass, items, interval, showFirst) {
+  function injectBetween(klass, items, interval, showFirst, poolKey) {
+    if (!items.length) return 0;
     let inserted = 0;
-    const poolKey = KIND[klass].pool;
+
     for (const el of items) {
-      if (inserted >= CFG.maxInsertsPerRun) break;
+      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 (adjacentManagedWrap(el)) continue;
+      if (adjacentWrap(el)) continue;
+
       const key = anchorKey(klass, el);
-      if (findWrapByKey(key)) continue;
+      if (findWrap(key)) continue;
+
       const id = pickId(poolKey);
-      if (!id) break; // no recycle = anti-churn by design
-      if (insertWrapAfter(el, id, klass, key)) inserted++;
+      if (id) {
+        const w = insertAfter(el, id, klass, key);
+        if (w) {
+          observePh(id);
+          if (!S.firstShown) { S.firstShown = true; enqueueShow(id); }
+          inserted++;
+        }
+      } else {
+        const recycled = recycleAndMove(klass, el, key);
+        if (!recycled) break;
+        inserted++;
+      }
     }
     return inserted;
   }
 
-  function canShowId(id) {
-    const t = now();
-    const last = S.lastShowById.get(id) || 0;
-    if (t - last < CFG.showThrottleMs) return false;
-    const rec = S.regById.get(id);
-    if (rec && rec.cooldownUntil && t < rec.cooldownUntil) return false;
-    const ph = phEl(id);
-    if (!ph?.isConnected) return false;
-    const wrap = ph.closest?.(`.${WRAP_CLASS}`);
-    if (!wrap?.isConnected) return false;
-    if (!wrapNearViewport(wrap)) {
-      // allow preloading within IO margin only if reasonably close
-      try {
-        const r = ph.getBoundingClientRect();
-        const vh = window.innerHeight || 800;
-        const preload = isMobile() ? 1800 : 1400;
-        if (r.top > vh + preload || r.bottom < -preload) return false;
-      } catch (_) {}
-    }
-    return true;
+  // ── IntersectionObserver & Show ────────────────────────────────────────────
+
+  function getIO() {
+    if (S.io) return S.io;
+    try {
+      S.io = new IntersectionObserver(entries => {
+        for (const e of entries) {
+          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 (Number.isFinite(id) && id > 0) enqueueShow(id);
+        }
+      }, { root: null, rootMargin: isMobile() ? IO_MARGIN_MOBILE : IO_MARGIN_DESKTOP, threshold: 0 });
+    } catch (_) { S.io = null; }
+    return S.io;
+  }
+
+  function observePh(id) {
+    const ph = document.getElementById(`${PH_PREFIX}${id}`);
+    if (ph?.isConnected) try { getIO()?.observe(ph); } catch (_) {}
   }
 
   function enqueueShow(id) {
-    if (isBlocked()) return;
-    const n = parseInt(id, 10);
-    if (!Number.isFinite(n) || n <= 0) return;
-    if (!S.pendingSet.has(n)) { S.pendingSet.add(n); S.pendingShow.push(n); }
-    if (!S.showTimer) {
-      S.showTimer = setTimeout(() => {
-        S.showTimer = 0;
-        drainShowQueue();
-      }, CFG.batchFlushMs);
+    if (!id || isBlocked()) 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;
     }
+    startShow(id);
   }
 
-  function observePlaceholder(id) {
-    const ph = phEl(id);
-    if (!ph?.isConnected) return;
-    try { getIO()?.observe(ph); } catch (_) {}
-    try {
-      const r = ph.getBoundingClientRect();
-      const vh = window.innerHeight || 800;
-      const preload = isMobile() ? 1600 : 1200;
-      if (r.top <= vh + preload && r.bottom >= -preload) enqueueShow(id);
-    } catch (_) {}
+  function drainQueue() {
+    if (isBlocked()) return;
+    while (S.inflight < MAX_INFLIGHT && S.pending.length) {
+      const id = S.pending.shift();
+      S.pendingSet.delete(id);
+      startShow(id);
+    }
   }
 
-  function startShow(ids) {
-    if (!ids.length || isBlocked()) return;
-    S.inflightShow += ids.length;
-    let released = false;
+  function startShow(id) {
+    if (!id || isBlocked()) return;
+    S.inflight++;
+    let done = false;
     const release = () => {
-      if (released) return;
-      released = true;
-      S.inflightShow = Math.max(0, S.inflightShow - ids.length);
-      drainShowQueue();
+      if (done) return;
+      done = true;
+      S.inflight = Math.max(0, S.inflight - 1);
+      drainQueue();
     };
-    const guard = setTimeout(release, CFG.showFailsafeMs);
+    const timer = setTimeout(release, 7000);
 
     requestAnimationFrame(() => {
       try {
-        if (isBlocked()) { clearTimeout(guard); return release(); }
+        if (isBlocked()) { clearTimeout(timer); return release(); }
+        const ph = document.getElementById(`${PH_PREFIX}${id}`);
+        if (!ph?.isConnected || isFilled(ph)) { 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);
+
+        try { ph.closest?.(`.${WRAP_CLASS}`)?.setAttribute(A_SHOWN, String(t)); } catch (_) {}
+
         window.ezstandalone = window.ezstandalone || {};
         const ez = window.ezstandalone;
-        const valid = [];
-        const t = now();
-        for (const id of ids) {
-          if (!canShowId(id)) continue;
-          const ph = phEl(id);
-          const wrap = ph?.closest?.(`.${WRAP_CLASS}`);
-          if (!wrap) continue;
-          wrap.setAttribute(A_SHOWN, String(t));
-          const rec = ensureRegistry(id, wrap);
-          rec.wrap = wrap;
-          rec.shownAt = t;
-          rec.lastMutationAt = t;
-          rec.cooldownUntil = t + CFG.showCooldownMs;
-          classifyWrap(rec);
-          updateWrapState(rec, 'showing');
-          S.lastShowById.set(id, t);
-          valid.push(id);
-        }
-        if (!valid.length) { clearTimeout(guard); return release(); }
-        const run = () => {
-          try { ez.showAds(...valid); } catch (_) {
-            try { ez.showAds(valid); } catch (_) {}
-          }
-          setTimeout(() => {
-            for (const id of valid) {
-              const rec = S.regById.get(id);
-              if (!rec) continue;
-              const w = rec.wrap;
-              if (w?.isConnected) {
-                if (isFilled(w)) rec.lastMutationAt = now();
-                updateWrapState(rec, 'live');
-              }
-            }
-            clearTimeout(guard);
-            release();
-          }, CFG.showReleaseMs);
+        const doShow = () => {
+          try { ez.showAds(id); } catch (_) {}
+          scheduleEmptyCheck(id, t);
+          setTimeout(() => { clearTimeout(timer); release(); }, 700);
         };
-        Array.isArray(ez.cmd) ? ez.cmd.push(run) : run();
-      } catch (_) {
-        clearTimeout(guard);
-        release();
-      }
+        Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
+      } catch (_) { clearTimeout(timer); release(); }
     });
   }
 
-  function drainShowQueue() {
-    if (isBlocked()) return;
-    if (S.inflightShow >= CFG.maxShowInflight) return;
-    if (!S.pendingShow.length) return;
-    const cap = Math.min(CFG.maxShowBatch, CFG.maxShowInflight - S.inflightShow);
-    const picked = [];
-    while (S.pendingShow.length && picked.length < cap) {
-      const id = S.pendingShow.shift();
-      S.pendingSet.delete(id);
-      if (!Number.isFinite(id) || id <= 0) continue;
-      if (!phEl(id)?.isConnected) continue;
-      picked.push(id);
-    }
-    if (picked.length) startShow(picked);
-    if (S.pendingShow.length) scheduleMaintenance();
+  function scheduleEmptyCheck(id, showTs) {
+    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);
   }
 
-  function getIO() {
-    if (S.io) return S.io;
-    try {
-      S.io = new IntersectionObserver(entries => {
-        for (const e of entries) {
-          const t = e.target;
-          if (!(t instanceof Element)) continue;
-          const id = parseInt(t.getAttribute('data-ezoic-id'), 10);
-          if (!Number.isFinite(id) || id <= 0) continue;
-          const rec = S.regById.get(id);
-          if (rec) rec.lastSeenAt = now();
-          if (e.isIntersecting) enqueueShow(id);
-        }
-      }, {
-        root: null,
-        rootMargin: isMobile() ? CFG.ioMarginMobile : CFG.ioMarginDesktop,
-        threshold: 0,
-      });
-    } catch (_) { S.io = null; }
-    return S.io;
-  }
+  // ── 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 install = () => {
+    const apply = () => {
       try {
         window.ezstandalone = window.ezstandalone || {};
         const ez = window.ezstandalone;
-        if (window.__nbbEzPatchedV22 || typeof ez.showAds !== 'function') return;
-        window.__nbbEzPatchedV22 = true;
+        if (window.__nbbEzPatched || typeof ez.showAds !== 'function') return;
+        window.__nbbEzPatched = true;
         const orig = ez.showAds.bind(ez);
         ez.showAds = function (...args) {
           if (isBlocked()) return;
-          const ids = (args.length === 1 && Array.isArray(args[0])) ? args[0] : args;
-          const valid = [];
+          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);
             if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-            const ph = phEl(id);
-            if (!ph?.isConnected) continue;
-            const wrap = ph.closest?.(`.${WRAP_CLASS}`);
-            if (!wrap?.isConnected) continue;
-            const rec = ensureRegistry(id, wrap);
-            if (rec.cooldownUntil && now() < rec.cooldownUntil && (now() - (rec.shownAt || 0)) < 500) continue;
+            if (!document.getElementById(`${PH_PREFIX}${id}`)?.isConnected) continue;
             seen.add(id);
-            valid.push(id);
+            try { orig(id); } catch (_) {}
           }
-          if (!valid.length) return;
-          try { return orig(...valid); } catch (_) { try { return orig(valid); } catch (_) {} }
         };
       } catch (_) {}
     };
-    install();
-    if (!window.__nbbEzPatchedV22) {
+    apply();
+    if (!window.__nbbEzPatched) {
       window.ezstandalone = window.ezstandalone || {};
-      (window.ezstandalone.cmd = window.ezstandalone.cmd || []).push(install);
+      (window.ezstandalone.cmd = window.ezstandalone.cmd || []).push(apply);
     }
   }
 
-  function healFalseEmpty(root) {
-    try {
-      const list = [];
-      if (root instanceof Element && root.classList.contains(WRAP_CLASS)) list.push(root);
-      if (root?.querySelectorAll) {
-        for (const w of root.querySelectorAll(`.${WRAP_CLASS}.is-empty`)) list.push(w);
-      }
-      for (const w of list) {
-        if (w.classList.contains('is-empty') && isFilled(w)) w.classList.remove('is-empty');
+  // ── Core ───────────────────────────────────────────────────────────────────
+
+  async function runCore() {
+    if (isBlocked()) return 0;
+    patchShowAds();
+
+    const cfg = await fetchConfig();
+    if (!cfg || cfg.excluded) return 0;
+    initPools(cfg);
+
+    const kind = getKind();
+    if (kind === 'other') return 0;
+
+    const exec = (klass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
+      if (!normBool(cfgEnable)) return 0;
+      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 === 'categoryTopics') {
+      pruneOrphansBetween();
+      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'
+    );
+  }
+
+  // ── Scheduler ──────────────────────────────────────────────────────────────
+
+  function scheduleRun(cb) {
+    if (S.runQueued) return;
+    S.runQueued = true;
+    requestAnimationFrame(async () => {
+      S.runQueued = false;
+      if (S.pageKey && pageKey() !== S.pageKey) return;
+      let n = 0;
+      try { n = await runCore(); } catch (_) {}
+      try { cb?.(n); } catch (_) {}
+    });
+  }
+
+  function requestBurst() {
+    if (isBlocked()) return;
+    const t = ts();
+    if (t - S.lastBurstTs < BURST_COOLDOWN_MS) return;
+    S.lastBurstTs   = t;
+    S.pageKey       = pageKey();
+    S.burstDeadline = t + 2000;
+
+    if (S.burstActive) return;
+    S.burstActive = true;
+    S.burstCount  = 0;
+
+    const step = () => {
+      if (pageKey() !== S.pageKey || isBlocked() || ts() > S.burstDeadline || S.burstCount >= 8) {
+        S.burstActive = false; return;
       }
-    } catch (_) {}
+      S.burstCount++;
+      scheduleRun(n => {
+        if (!n && !S.pending.length) { S.burstActive = false; return; }
+        setTimeout(step, n > 0 ? 150 : 300);
+      });
+    };
+    step();
+  }
+
+  // ── Cleanup navigation ─────────────────────────────────────────────────────
+
+  function cleanup() {
+    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.pendingSet.clear();
+    S.burstActive  = false;
+    S.runQueued    = false;
+    S.firstShown   = false;
   }
 
-  function ensureObserver() {
+  // ── MutationObserver ───────────────────────────────────────────────────────
+
+  function ensureDomObserver() {
     if (S.domObs) return;
     S.domObs = new MutationObserver(muts => {
-      if (S.muting > 0 || isBlocked()) return;
-      let shouldRun = false;
+      if (S.mutGuard > 0 || isBlocked()) return;
+      const relevant = (() => {
+        const k = getKind();
+        if (k === 'topic') return [SEL.post];
+        if (k === 'categoryTopics') return [SEL.topic];
+        if (k === 'categories') return [SEL.category];
+        return [SEL.post, SEL.topic, SEL.category];
+      })();
       for (const m of muts) {
         for (const n of m.addedNodes) {
-          if (!(n instanceof Element)) continue;
-          healFalseEmpty(n);
-          const wrap = n.classList?.contains(WRAP_CLASS) ? n : n.querySelector?.(`.${WRAP_CLASS}`);
-          if (wrap) {
-            const id = parseInt(wrap.getAttribute(A_WRAPID), 10);
-            if (Number.isFinite(id)) {
-              const rec = ensureRegistry(id, wrap);
-              rec.lastMutationAt = now();
-              classifyWrap(rec);
-            }
-          }
-          if (n.matches?.(SEL.post) || n.matches?.(SEL.topic) || n.matches?.(SEL.category) ||
-              n.querySelector?.(SEL.post) || n.querySelector?.(SEL.topic) || n.querySelector?.(SEL.category)) {
-            shouldRun = true;
+          if (n.nodeType !== 1) continue;
+          // matches() d'abord (O(1)), querySelector() seulement si nécessaire
+          if (relevant.some(s => { try { return n.matches(s); } catch(_){return false;} }) ||
+              relevant.some(s => { try { return !!n.querySelector(s); } catch(_){return false;} })) {
+            requestBurst(); return;
           }
         }
-        for (const n of m.removedNodes) {
-          if (!(n instanceof Element)) continue;
-          if (n.classList?.contains(WRAP_CLASS) || n.querySelector?.(`.${WRAP_CLASS}`)) {
-            shouldRun = true;
-          }
-        }
-      }
-      if (shouldRun) {
-        scheduleRun();
-        scheduleMaintenance();
       }
     });
     try { S.domObs.observe(document.body, { childList: true, subtree: true }); } catch (_) {}
   }
 
+  // ── 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}`,
+    ];
+    for (const m of ['log', 'info', 'warn', 'error']) {
+      const orig = console[m];
+      if (typeof orig !== 'function') continue;
+      console[m] = function (...a) {
+        if (typeof a[0] === 'string' && MUTED.some(p => a[0].includes(p))) return;
+        orig.apply(console, a);
+      };
+    }
+  }
+
   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';
+        f.style.display = 'none'; f.id = f.name = '__tcfapiLocator';
         (document.body || document.documentElement).appendChild(f);
       };
       inject();
-      if (!window.__nbbTcfObsV22) {
-        window.__nbbTcfObsV22 = new MutationObserver(inject);
-        window.__nbbTcfObsV22.observe(document.documentElement, { childList: true, subtree: true });
+      if (!window.__nbbTcfObs) {
+        window.__nbbTcfObs = new MutationObserver(inject);
+        window.__nbbTcfObs.observe(document.documentElement, { childList: true, subtree: true });
       }
     } catch (_) {}
   }
 
-  const warmed = new Set();
+  const _warmed = new Set();
   function warmNetwork() {
     const head = document.head;
     if (!head) return;
-    const frag = document.createDocumentFragment();
-    const defs = [
-      ['preconnect', 'https://g.ezoic.net', true],
-      ['preconnect', 'https://go.ezoic.net', true],
-      ['preconnect', 'https://securepubads.g.doubleclick.net', true],
-      ['dns-prefetch', 'https://g.ezoic.net', false],
+    for (const [rel, href, cors] of [
+      ['preconnect',   'https://g.ezoic.net',                    true ],
+      ['preconnect',   'https://go.ezoic.net',                   true ],
+      ['preconnect',   'https://securepubads.g.doubleclick.net', true ],
+      ['preconnect',   'https://pagead2.googlesyndication.com',  true ],
+      ['dns-prefetch', 'https://g.ezoic.net',                    false],
       ['dns-prefetch', 'https://securepubads.g.doubleclick.net', false],
-    ];
-    for (const [rel, href, cors] of defs) {
-      const key = `${rel}|${href}`;
-      if (warmed.has(key)) continue;
-      warmed.add(key);
+    ]) {
+      const k = `${rel}|${href}`;
+      if (_warmed.has(k)) continue;
+      _warmed.add(k);
+      if (head.querySelector(`link[rel="${rel}"][href="${href}"]`)) continue;
       const l = document.createElement('link');
       l.rel = rel; l.href = href;
       if (cors) l.crossOrigin = 'anonymous';
-      frag.appendChild(l);
+      head.appendChild(l);
     }
-    head.appendChild(frag);
   }
 
-  async function runCore() {
-    if (isBlocked()) return 0;
-    patchShowAds();
-    const cfg = await fetchConfig();
-    if (!cfg || cfg.excluded) return 0;
-    initPools(cfg);
-
-    const kind = getKind();
-    if (kind === 'other') return 0;
-
-    if (kind === 'topic') {
-      if (!normBool(cfg.enableMessageAds)) return 0;
-      const interval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
-      return injectFor('ezoic-ad-message', getPosts(), interval, normBool(cfg.showFirstMessageAd));
-    }
-
-    if (kind === 'categoryTopics') {
-      if (!normBool(cfg.enableBetweenAds)) return 0;
-      const interval = Math.max(1, parseInt(cfg.intervalPosts, 10) || 3);
-      return injectFor('ezoic-ad-between', getTopics(), interval, normBool(cfg.showFirstTopicAd));
-    }
-
-    if (!normBool(cfg.enableCategoryAds)) return 0;
-    const interval = Math.max(1, parseInt(cfg.intervalCategories, 10) || 3);
-    return injectFor('ezoic-ad-categories', getCategories(), interval, normBool(cfg.showFirstCategoryAd));
-  }
-
-  function scheduleRun() {
-    if (isBlocked()) return;
-    if (S.runTimer) return;
-    S.runTimer = setTimeout(async () => {
-      S.runTimer = 0;
-      const pk = pageKey();
-      if (S.pageKey && S.pageKey !== pk) return;
-      try { await runCore(); } catch (_) {}
-      scheduleMaintenance();
-    }, CFG.runDebounceMs);
-  }
-
-  function cleanup() {
-    S.blockedUntil = now() + 1500;
-    if (S.runTimer) { clearTimeout(S.runTimer); S.runTimer = 0; }
-    if (S.showTimer) { clearTimeout(S.showTimer); S.showTimer = 0; }
-    if (S.maintenanceTimer) { clearTimeout(S.maintenanceTimer); S.maintenanceTimer = 0; }
-    mutate(() => {
-      for (const w of document.querySelectorAll(`.${WRAP_CLASS}`)) releaseWrap(w);
-    });
-    S.cfg = null;
-    S.poolsReady = false;
-    S.pools = { topics: [], posts: [], categories: [] };
-    S.cursors = { topics: 0, posts: 0, categories: 0 };
-    S.mountedIds.clear();
-    S.wrapByKey.clear();
-    S.regById.clear();
-    S.pendingShow = [];
-    S.pendingSet.clear();
-    S.lastShowById.clear();
-    S.inflightShow = 0;
-  }
+  // ── Bindings ───────────────────────────────────────────────────────────────
 
   function bindNodeBB() {
     const $ = window.jQuery;
     if (!$) return;
-    $(window).off('.nbbEzoicV22');
-    $(window).on('action:ajaxify.start.nbbEzoicV22', cleanup);
-    $(window).on('action:ajaxify.end.nbbEzoicV22', () => {
-      S.pageKey = pageKey();
-      S.blockedUntil = 0;
-      ensureTcfLocator();
-      warmNetwork();
-      patchShowAds();
-      getIO();
-      ensureObserver();
-      scheduleRun();
+
+    $(window).off('.nbbEzoic');
+    $(window).on('action:ajaxify.start.nbbEzoic', cleanup);
+    $(window).on('action:ajaxify.end.nbbEzoic', () => {
+      S.pageKey    = pageKey();
+      S.kind       = null;
+      blockedUntil = 0;
+      muteConsole(); ensureTcfLocator(); warmNetwork();
+      patchShowAds(); getIO(); ensureDomObserver(); requestBurst();
     });
-    const events = [
+
+    const burstEvts = [
       'action:ajaxify.contentLoaded', 'action:posts.loaded', 'action:topics.loaded',
       'action:categories.loaded', 'action:category.loaded', 'action:topic.loaded',
-    ];
-    for (const ev of events) {
-      $(window).on(`${ev}.nbbEzoicV22`, () => { if (!isBlocked()) scheduleRun(); });
-    }
+    ].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']) {
-          try { hooks.on(ev, () => { if (!isBlocked()) scheduleRun(); }); } catch (_) {}
+        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 (_) {}
@@ -809,24 +868,22 @@
     window.addEventListener('scroll', () => {
       if (ticking) return;
       ticking = true;
-      requestAnimationFrame(() => {
-        ticking = false;
-        if (!isBlocked()) {
-          scheduleMaintenance();
-          scheduleRun();
-        }
-      });
+      requestAnimationFrame(() => { ticking = false; requestBurst(); });
     }, { passive: true });
   }
 
+  // ── Boot ───────────────────────────────────────────────────────────────────
+
   S.pageKey = pageKey();
+  muteConsole();
   ensureTcfLocator();
   warmNetwork();
   patchShowAds();
   getIO();
-  ensureObserver();
+  ensureDomObserver();
   bindNodeBB();
   bindScroll();
-  S.blockedUntil = 0;
-  scheduleRun();
+  blockedUntil = 0;
+  requestBurst();
+
 })();