nodebb-plugin-ezoic-infinite 1.8.13 → 1.8.15

package/public/client.js

@@ -1,96 +1,55 @@
 /**
- * NodeBB Ezoic Infinite Ads — client.js v36
+ * NodeBB Ezoic Infinite Ads — client.js (v20)
  *
- * Historique des corrections majeures
- * ────────────────────────────────────
- * v18  Ancrage stable par data-pid / data-index au lieu d'ordinalMap fragile.
+ * Correctifs critiques vs v19
+ * ───────────────────────────
+ * [BUG FATAL] Pubs catégories disparaissent au premier scroll sur mobile
+ *   pruneOrphans cherchait l'ancre via `[data-index]`, mais les éléments
+ *   `li[component="categories/category"]` ont `data-cid`, pas `data-index`.
+ *   → anchorEl toujours null → suppression à chaque runCore() → disparition.
+ *   Fix : table KIND_META qui mappe chaque kindClass vers son attribut d'ancre
+ *   stable (data-pid pour posts, data-index pour topics, data-cid pour catégories).
  *
- * v19  Intervalle global basé sur l'ordinal absolu (data-index), pas sur
- *      la position dans le batch courant.
+ * [BUG] decluster : break trop large stoppait tout quand UN wrap était en grâce
+ *   Fix : on skip uniquement le wrap courant, pas toute la boucle.
  *
- * 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.
+ * [BUG] injectBetween : `break` sur pool épuisé empêchait d'observer les wraps
+ *   existants sur les items suivants. Fix : `continue` au lieu de `break`.
  *
- * v25  Fix scroll-up / virtualisation NodeBB : decluster + grace period.
+ * [PERF] IntersectionObserver recréé à chaque scroll boost → très coûteux mobile.
+ *   Fix : marge large fixe par device, observer créé une seule fois.
  *
- * v26  Suppression définitive du recyclage d'id (causait réinjection en haut).
+ * [PERF] Burst cooldown 100ms trop court sur mobile → rafales en cascade.
+ *   Fix : 200ms.
  *
- * 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.
+ * Nettoyage
+ * ─────────
+ * - Suppression du scroll boost (complexité sans gain mesurable côté SPA statique)
+ * - MAX_INFLIGHT unique desktop/mobile (inutile de différencier)
+ * - getAnchorKey/getGlobalOrdinal fusionnés en helpers cohérents
+ * - Commentaires internes allégés (code auto-documenté)
  */
-(function nbbEzoicInfinite() {
+(function () {
   'use strict';
 
   // ── 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
-
-  // Tunables (stables en prod)
-  const MIN_PRUNE_AGE_MS  = 8_000;   // délai de grâce avant pruning (stabilisation DOM)
-  const MAX_INSERTS_RUN   = 10;      // plus réactif si NodeBB injecte en rafale
-  const MAX_INFLIGHT      = 2;       // ids max simultanés en vol (garde-fou)
-  const MAX_SHOW_BATCH    = 4;       // ids max par appel showAds(...ids)
-  const SHOW_THROTTLE_MS  = 500;     // anti-spam showAds() par id (plus réactif)
-  const SHOW_RELEASE_MS   = 300;     // relâche inflight après showAds() batché
-  const SHOW_FAILSAFE_MS  = 7000;    // relâche forcée si stack pub lente
-  const BATCH_FLUSH_MS    = 30;      // micro-buffer pour regrouper les ids proches
-  const MAX_DESTROY_BATCH  = 4;       // ids max par destroyPlaceholders(...ids)
-  const DESTROY_FLUSH_MS   = 30;      // micro-buffer destroy pour lisser les rafales
-  const BURST_COOLDOWN_MS = 100;     // délai min entre deux déclenchements de burst
-
-  // Marges IO larges et fixes — observer créé une seule fois au boot
+  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 (number string)
+  const A_CREATED          = 'data-ezoic-created';  // timestamp création (ms)
+  const A_SHOWN            = 'data-ezoic-shown';    // timestamp dernier showAds (ms)
+
+  const MIN_PRUNE_AGE_MS   = 8_000;   // délai avant qu'un wrap puisse être purgé
+  const FILL_GRACE_MS      = 25_000;  // fenêtre post-showAds où l'on ne decluster pas
+  const EMPTY_CHECK_MS     = 20_000;  // délai avant de marquer un wrap vide
+  const MAX_INSERTS_PER_RUN = 6;
+  const MAX_INFLIGHT        = 4;
+  const SHOW_THROTTLE_MS    = 900;
+  const BURST_COOLDOWN_MS   = 200;
+
+  // Marges IO larges et fixes (pas de reconstruction d'observer)
   const IO_MARGIN_DESKTOP = '2500px 0px 2500px 0px';
   const IO_MARGIN_MOBILE  = '3500px 0px 3500px 0px';
 
@@ -101,49 +60,42 @@
   };
 
   /**
-   * Table KIND — source de vérité par kindClass.
+   * Table centrale : kindClass → { selector DOM, attribut d'ancre stable }
    *
-   * 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)
+   * L'attribut d'ancre est l'identifiant que NodeBB pose TOUJOURS sur l'élément,
+   * quelle que soit la page ou la virtualisation :
+   *   posts    → data-pid   (id du message, unique et permanent)
+   *   topics   → data-index (position 0-based dans la liste, fourni par NodeBB)
+   *   catégories → data-cid (id de la catégorie, unique et permanent)
+   *                          ← C'était le bug v19 : on cherchait data-index ici
    */
   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         },
+    'ezoic-ad-message':    { sel: SEL.post,     anchorAttr: 'data-pid'   },
+    'ezoic-ad-between':    { sel: SEL.topic,    anchorAttr: 'data-index' },
+    'ezoic-ad-categories': { sel: SEL.category, anchorAttr: 'data-cid'   },
   };
 
-  // ── État global ────────────────────────────────────────────────────────────
+  // ── État ───────────────────────────────────────────────────────────────────
 
   const S = {
-    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(),
-    showBatchTimer: 0,
-    destroyBatchTimer: 0,
-    destroyPending: [],
-    destroyPendingSet: new Set(),
-    sweepQueued:  false,
-    wrapByKey:    new Map(),  // anchorKey → wrap DOM node
-    ezActiveIds:  new Set(),  // ids actifs côté plugin (wrap présent / récemment show)
-    ezShownSinceDestroy: new Set(), // ids déjà show depuis le dernier destroy Ezoic
-    scrollDir:    1,          // 1=bas, -1=haut
-    scrollSpeed:  0,          // px/s approx (EMA)
-    lastScrollY:  0,
-    lastScrollTs: 0,
+    pageKey: null,
+    cfg: null,
+    poolSig: null,
+
+    pools:      { topics: [], posts: [], categories: [] },
+    cursors:    { topics: 0,  posts: 0,  categories: 0  },
+    mountedIds: new Set(),      // IDs Ezoic actuellement dans le DOM
+    lastShow:   new Map(),      // id → timestamp dernier show
+
+    io:      null,
+    ioMargin: null,
+    domObs:  null,
+    mutGuard: 0,                // compteur internalMutation
+
+    inflight:    0,
+    pending:     [],
+    pendingSet:  new Set(),
+
     runQueued:    false,
     burstActive:  false,
     burstDeadline: 0,
@@ -152,127 +104,13 @@
   };
 
   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 healFalseEmpty(root = document) {
-    try {
-      const list = [];
-      if (root instanceof Element && root.classList?.contains(WRAP_CLASS)) list.push(root);
-      const found = root.querySelectorAll ? root.querySelectorAll(`.${WRAP_CLASS}.is-empty`) : [];
-      for (const w of found) list.push(w);
-      for (const w of list) {
-        if (!w?.classList?.contains('is-empty')) continue;
-        if (isFilled(w)) w.classList.remove('is-empty');
-      }
-    } catch (_) {}
-  }
-
-  function phEl(id) {
-    return document.getElementById(`${PH_PREFIX}${id}`);
-  }
-
-  function hasSinglePlaceholder(id) {
-    try { return document.querySelectorAll(`#${PH_PREFIX}${id}`).length === 1; } catch (_) { return false; }
-  }
-
-  function canShowPlaceholderId(id, now = ts()) {
-    const n = parseInt(id, 10);
-    if (!Number.isFinite(n) || n <= 0) return false;
-    if (now - (S.lastShow.get(n) ?? 0) < SHOW_THROTTLE_MS) return false;
-    const ph = phEl(n);
-    if (!ph?.isConnected || isFilled(ph)) return false;
-    if (!hasSinglePlaceholder(n)) return false;
-    return true;
-  }
-
-  function queueSweepDeadWraps() {
-    if (S.sweepQueued) return;
-    S.sweepQueued = true;
-    requestAnimationFrame(() => {
-      S.sweepQueued = false;
-      sweepDeadWraps();
-    healFalseEmpty();
-    });
-  }
-
-  function getDynamicShowBatchMax() {
-    const speed = S.scrollSpeed || 0;
-    const pend  = S.pending.length;
-    // Scroll très rapide => petits batches (réduit le churn/unused)
-    if (speed > 2600) return 2;
-    if (speed > 1400) return 3;
-    // Peu de candidats => flush plus vite, inutile d'attendre 4
-    if (pend <= 1) return 1;
-    if (pend <= 3) return 2;
-    // Par défaut compromis dynamique
-    return 3;
-  }
+  const isBlocked  = () => Date.now() < blockedUntil;
+  const ts         = () => Date.now();
 
   function mutate(fn) {
     S.mutGuard++;
     try { fn(); } finally { S.mutGuard--; }
   }
-function scheduleDestroyFlush() {
-  if (S.destroyBatchTimer) return;
-  S.destroyBatchTimer = setTimeout(() => {
-    S.destroyBatchTimer = 0;
-    flushDestroyBatch();
-  }, DESTROY_FLUSH_MS);
-}
-
-function flushDestroyBatch() {
-  if (!S.destroyPending.length) return;
-  const ids = [];
-  while (S.destroyPending.length && ids.length < MAX_DESTROY_BATCH) {
-    const id = S.destroyPending.shift();
-    S.destroyPendingSet.delete(id);
-    if (!Number.isFinite(id) || id <= 0) continue;
-    ids.push(id);
-  }
-  if (ids.length) {
-    try {
-      const ez = window.ezstandalone;
-      const run = () => { try { ez?.destroyPlaceholders?.(ids); } catch (_) {} };
-      try { (typeof ez?.cmd?.push === 'function') ? ez.cmd.push(run) : run(); } catch (_) {}
-    } catch (_) {}
-  }
-  if (S.destroyPending.length) scheduleDestroyFlush();
-}
-
-function destroyEzoicId(id) {
-  if (!Number.isFinite(id) || id <= 0) return;
-  if (!S.ezActiveIds.has(id)) return;
-  S.ezActiveIds.delete(id);
-  if (!S.destroyPendingSet.has(id)) {
-    S.destroyPending.push(id);
-    S.destroyPendingSet.add(id);
-  }
-  scheduleDestroyFlush();
-}
-
-function destroyBeforeReuse(ids) {
-  const out = [];
-  const toDestroy = [];
-  const seen = new Set();
-  for (const raw of (ids || [])) {
-    const id = parseInt(raw, 10);
-    if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-    seen.add(id);
-    out.push(id);
-    if (S.ezShownSinceDestroy.has(id)) toDestroy.push(id);
-  }
-  if (toDestroy.length) {
-    try { window.ezstandalone?.destroyPlaceholders?.(toDestroy); } catch (_) {}
-    for (const id of toDestroy) S.ezShownSinceDestroy.delete(id);
-  }
-  return out;
-}
-
 
   // ── Config ─────────────────────────────────────────────────────────────────
 
@@ -285,22 +123,44 @@ function destroyBeforeReuse(ids) {
     return S.cfg;
   }
 
+  function initPools(cfg) {
+    // (Perf) Ne reparse les pools que si les strings ont changé.
+    const sig = `${cfg.placeholderIds || ''}§${cfg.messagePlaceholderIds || ''}§${cfg.categoryPlaceholderIds || ''}`;
+    if (S.poolSig === sig) return;
+    S.poolSig = sig;
+
+    S.pools.topics     = parseIds(cfg.placeholderIds);
+    S.pools.posts      = parseIds(cfg.messagePlaceholderIds);
+    S.pools.categories = parseIds(cfg.categoryPlaceholderIds);
+
+    // Réinitialise les curseurs si une pool change
+    S.cursors.topics = 0;
+    S.cursors.posts = 0;
+    S.cursors.categories = 0;
+  }
+
   function parseIds(raw) {
+    // Accepte : un ID par ligne, ou séparés par virgules/espaces (ACP le mentionne).
     const out = [], seen = new Set();
-    for (const v of String(raw || '').split(/\r?\n/).map(s => s.trim()).filter(Boolean)) {
+    const parts = String(raw || '')
+      .replace(/\r/g, '\n')
+      .split(/[\n\s,]+/)
+      .map(s => s.trim())
+      .filter(Boolean);
+
+    for (const v of parts) {
       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;
-  }
+  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]'));
+
+  const isMobile = () => { try { return window.innerWidth < 768; } catch (_) { return false; } };
 
   // ── Page identity ──────────────────────────────────────────────────────────
 
@@ -324,13 +184,13 @@ function destroyBeforeReuse(ids) {
     return 'other';
   }
 
-  // ── Items DOM ──────────────────────────────────────────────────────────────
+  // ── DOM helpers ────────────────────────────────────────────────────────────
 
   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('[component="post"][data-pid]');
       if (p && p !== el) return false;
       return el.getAttribute('component') !== 'post/parent';
     });
@@ -339,87 +199,53 @@ function destroyBeforeReuse(ids) {
   const getTopics     = () => Array.from(document.querySelectorAll(SEL.topic));
   const getCategories = () => Array.from(document.querySelectorAll(SEL.category));
 
-  // ── 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(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 (_) {}
-      }
-    }
-    // Dernier recours : querySelector global
-    try {
-      const found = document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`);
-      return !!(found?.isConnected);
-    } catch (_) { return false; }
-  }
-
   function adjacentWrap(el) {
-    return wrapIsLive(el.nextElementSibling) || wrapIsLive(el.previousElementSibling);
+    return !!(
+      el.nextElementSibling?.classList?.contains(WRAP_CLASS) ||
+      el.previousElementSibling?.classList?.contains(WRAP_CLASS)
+    );
   }
 
-  // ── Ancres stables ─────────────────────────────────────────────────────────
+  // ── Ancres stables ────────────────────────────────────────────────────────
 
   /**
-   * Retourne la valeur de l'attribut stable pour cet élément,
-   * ou un fallback positionnel si l'attribut est absent.
+   * Retourne l'identifiant stable de l'élément selon son kindClass.
+   * Utilise l'attribut défini dans KIND (data-pid, data-index, data-cid).
+   * Fallback positionnel si l'attribut est absent.
    */
-  function stableId(klass, el) {
-    const attr = KIND[klass]?.anchorAttr;
+  function stableId(kindClass, el) {
+    const attr = KIND[kindClass]?.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++;
-    }
+    // Fallback : position dans le parent
+    try {
+      let i = 0;
+      for (const s of el.parentElement?.children ?? []) {
+        if (s === el) return `i${i}`;
+        i++;
+      }
+    } catch (_) {}
     return 'i0';
   }
 
-  const anchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
+  const makeAnchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
 
-  function findWrap(key) {
-    const w = S.wrapByKey.get(key);
-    return (w?.isConnected) ? w : null;
+  function findWrap(anchorKey) {
+    try {
+      return document.querySelector(
+        `.${WRAP_CLASS}[${A_ANCHOR}="${anchorKey.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"]`
+      );
+    } catch (_) { return null; }
   }
 
   // ── 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 i = S.cursors[poolKey] % pool.length;
+      const i  = S.cursors[poolKey] % pool.length;
       S.cursors[poolKey] = (S.cursors[poolKey] + 1) % pool.length;
       const id = pool[i];
       if (!S.mountedIds.has(id)) return id;
@@ -427,112 +253,7 @@ function destroyBeforeReuse(ids) {
     return null;
   }
 
-  function sweepDeadWraps() {
-    // NodeBB peut retirer des nœuds sans passer par dropWrap() (virtualisation / rerender).
-    // On libère alors les IDs/keys fantômes pour éviter l'épuisement du pool.
-    for (const [key, wrap] of Array.from(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);
-        S.lastShow.delete(id);
-        S.ezActiveIds.delete(id);
-      }
-    }
-    if (S.pending.length) {
-      S.pending = S.pending.filter(id => S.pendingSet.has(id));
-    }
-  }
-
-  /**
-   * 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;
-  const preferAbove = S.scrollDir >= 0; // scroll bas => recycle en haut
-  const farAbove = -vh;
-  const farBelow = vh * 2;
-
-  let bestPrefEmpty = null, bestPrefMetric = Infinity;
-  let bestPrefFilled = null, bestPrefFilledMetric = Infinity;
-  let bestAnyEmpty = null, bestAnyMetric = Infinity;
-  let bestAnyFilled = null, bestAnyFilledMetric = Infinity;
-
-  for (const wrap of S.wrapByKey.values()) {
-    if (!wrap?.isConnected || !wrap.classList?.contains(WRAP_CLASS) || !wrap.classList.contains(klass)) continue;
-    try {
-      const rect = wrap.getBoundingClientRect();
-      const isAbove = rect.bottom <= farAbove;
-      const isBelow = rect.top >= farBelow;
-      const anyFar = isAbove || isBelow;
-      if (!anyFar) continue;
-
-      const qualifies = preferAbove ? isAbove : isBelow;
-      const metric = preferAbove ? Math.abs(rect.bottom) : Math.abs(rect.top - vh);
-      const filled = isFilled(wrap);
-
-      if (qualifies) {
-        if (!filled) {
-          if (metric < bestPrefMetric) { bestPrefMetric = metric; bestPrefEmpty = wrap; }
-        } else {
-          if (metric < bestPrefFilledMetric) { bestPrefFilledMetric = metric; bestPrefFilled = wrap; }
-        }
-      }
-      if (!filled) {
-        if (metric < bestAnyMetric) { bestAnyMetric = metric; bestAnyEmpty = wrap; }
-      } else {
-        if (metric < bestAnyFilledMetric) { bestAnyFilledMetric = metric; bestAnyFilled = wrap; }
-      }
-    } catch (_) {}
-  }
-
-  const best = bestPrefEmpty ?? bestPrefFilled ?? bestAnyEmpty ?? bestAnyFilled;
-  if (!best) return null;
-  const id = parseInt(best.getAttribute(A_WRAPID), 10);
-  if (!Number.isFinite(id)) return null;
-
-  const oldKey = best.getAttribute(A_ANCHOR);
-  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);
-
-  const doDestroy = () => {
-    if (S.ezShownSinceDestroy.has(id)) {
-      try { ez.destroyPlaceholders([id]); } catch (_) {}
-      S.ezShownSinceDestroy.delete(id);
-    }
-    S.ezActiveIds.delete(id);
-    setTimeout(doDefine, 330);
-  };
-  const doDefine  = () => { try { ez.define([id]); } catch (_) {} setTimeout(doDisplay, 300); };
-  const doDisplay = () => { try { ez.displayMore([id]); S.ezActiveIds.add(id); S.ezShownSinceDestroy.add(id); } catch (_) {} };
-  try { (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doDestroy) : doDestroy(); } catch (_) {}
-
-  return { id, wrap: best };
-}
-
-
-  // ── Wraps DOM — création / suppression ────────────────────────────────────
+  // ── Wraps DOM ──────────────────────────────────────────────────────────────
 
   function makeWrap(id, klass, key) {
     const w = document.createElement('div');
@@ -540,7 +261,6 @@ function recycleAndMove(klass, targetEl, newKey) {
     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}`;
@@ -550,79 +270,115 @@ function recycleAndMove(klass, targetEl, newKey) {
   }
 
   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; // ancre déjà présente
+    if (S.mountedIds.has(id))     return null; // id déjà monté
     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);
     return w;
   }
 
   function dropWrap(w) {
     try {
-      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.ezActiveIds.delete(id); S.mountedIds.delete(id); }
-      const key = w.getAttribute(A_ANCHOR);
-      if (key && S.wrapByKey.get(key) === w) S.wrapByKey.delete(key);
+      if (Number.isFinite(id)) S.mountedIds.delete(id);
+      // IMPORTANT : ne passer unobserve que si c'est un vrai Element.
+      // unobserve(null) corrompt l'état interne de l'IO (pubads lève ensuite
+      // "parameter 1 is not of type Element" sur le prochain observe).
+      try {
+        const ph = w.querySelector(`[id^="${PH_PREFIX}"]`);
+        if (ph instanceof Element) S.io?.unobserve(ph);
+      } catch (_) {}
       w.remove();
     } catch (_) {}
   }
 
-  // ── 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];
+  // ── Prune ──────────────────────────────────────────────────────────────────
+
+  /**
+   * Supprime les wraps dont l'élément-ancre n'est plus dans le DOM.
+   *
+   * L'ancre est retrouvée via l'attribut stable défini dans KIND[kindClass].anchorAttr.
+   * Exemples :
+   *   ezoic-ad-message    → cherche [data-pid="123"]
+   *   ezoic-ad-between    → cherche [data-index="5"]
+   *   ezoic-ad-categories → cherche [data-cid="7"]   ← fix v20
+   *
+   * On ne prune pas les wraps < MIN_PRUNE_AGE_MS (DOM pas encore stabilisé).
+   */
+  function pruneOrphans(klass) {
+    const meta = KIND[klass];
+    if (!meta) return;
+
+    // (Perf) Construire 1 set d'ancres présentes, au lieu de querySelector par wrap.
+    const present = new Set();
+    try {
+      document.querySelectorAll(meta.sel).forEach(el => {
+        const v = el.getAttribute(meta.anchorAttr);
+        if (v !== null && v !== '') present.add(String(v));
+      });
+    } catch (_) {}
 
     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
+      if (ts() - parseInt(w.getAttribute(A_CREATED) || '0', 10) < MIN_PRUNE_AGE_MS) return;
 
       const key = w.getAttribute(A_ANCHOR) ?? '';
-      const sid = key.slice(klass.length + 1); // après "ezoic-ad-between:"
+      const sid = key.slice(klass.length + 1); // après "kindClass:"
       if (!sid) { mutate(() => dropWrap(w)); return; }
 
-      const anchorEl = document.querySelector(`${cfg.baseTag}[${cfg.anchorAttr}="${sid}"]`);
-      if (!anchorEl?.isConnected) mutate(() => dropWrap(w));
+      if (!present.has(String(sid))) mutate(() => dropWrap(w));
     });
   }
+// ── Decluster ──────────────────────────────────────────────────────────────
+
+  /**
+   * Deux wraps adjacents = situation anormale → supprimer le moins prioritaire.
+   * Priorité : filled > en grâce (fill en cours) > vide.
+   * Ne supprime jamais un wrap dont showAds() date de moins de FILL_GRACE_MS.
+   */
+  function decluster(klass) {
+    for (const w of document.querySelectorAll(`.${WRAP_CLASS}.${klass}`)) {
+      // Grace sur le wrap courant : on le saute entièrement
+      const wShown = parseInt(w.getAttribute(A_SHOWN) || '0', 10);
+      if (wShown && ts() - wShown < FILL_GRACE_MS) continue;
+
+      let prev = w.previousElementSibling, steps = 0;
+      while (prev && steps++ < 3) {
+        if (!prev.classList?.contains(WRAP_CLASS)) { prev = prev.previousElementSibling; continue; }
+
+        const pShown = parseInt(prev.getAttribute(A_SHOWN) || '0', 10);
+        if (pShown && ts() - pShown < FILL_GRACE_MS) break; // précédent en grâce → rien
+
+        if      (!isFilled(w))    mutate(() => dropWrap(w));
+        else if (!isFilled(prev)) mutate(() => dropWrap(prev));
+        break;
+      }
+    }
+  }
 
   // ── 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.
+   * Ordinal 0-based pour le calcul de l'intervalle.
+   * Pour posts/topics : data-index (NodeBB 3+/4+, toujours présent).
+   * Pour catégories : position dans le parent (page statique, pas d'infinite scroll).
    */
   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;
-    for (const s of el.parentElement?.children ?? []) {
-      if (s === el) return i;
-      if (!fullSel || s.matches?.(fullSel)) i++;
-    }
+    const di = el.getAttribute('data-index');
+    if (di !== null && di !== '' && !isNaN(di)) return parseInt(di, 10);
+    // Fallback positionnel
+    try {
+      const tag = KIND[klass]?.sel?.split('[')?.[0] ?? '';
+      if (tag) {
+        let i = 0;
+        for (const n of el.parentElement?.querySelectorAll(`:scope > ${tag}`) ?? []) {
+          if (n === el) return i;
+          i++;
+        }
+      }
+    } catch (_) {}
     return 0;
   }
 
@@ -631,26 +387,23 @@ function recycleAndMove(klass, targetEl, newKey) {
     let inserted = 0;
 
     for (const el of items) {
-      if (inserted >= MAX_INSERTS_RUN) break;
+      if (inserted >= MAX_INSERTS_PER_RUN) break;
       if (!el?.isConnected) continue;
 
-      const ord = ordinal(klass, el);
-      if (!(showFirst && ord === 0) && (ord + 1) % interval !== 0) continue;
+      const ord      = ordinal(klass, el);
+      const isTarget = (showFirst && ord === 0) || ((ord + 1) % interval === 0);
+      if (!isTarget) continue;
+
       if (adjacentWrap(el)) continue;
 
-      const key = anchorKey(klass, el);
-      if (findWrap(key)) continue;
-
-      let id = pickId(poolKey);
-      if (!id) { sweepDeadWraps(); id = pickId(poolKey); }
-      if (id) {
-        const w = insertAfter(el, id, klass, key);
-        if (w) { observePh(id); inserted++; }
-      } else {
-        const recycled = recycleAndMove(klass, el, key);
-        if (!recycled) break;
-        inserted++;
-      }
+      const key = makeAnchorKey(klass, el);
+      if (findWrap(key)) continue; // déjà là → pas de pickId inutile
+
+      const id = pickId(poolKey);
+      if (!id) continue; // pool momentanément épuisé, on continue (items suivants ≠ besoin d'id)
+
+      const w = insertAfter(el, id, klass, key);
+      if (w) { observePh(id); inserted++; }
     }
     return inserted;
   }
@@ -658,7 +411,14 @@ function recycleAndMove(klass, targetEl, newKey) {
   // ── IntersectionObserver & Show ────────────────────────────────────────────
 
   function getIO() {
-    if (S.io) return S.io;
+    const margin = isMobile() ? IO_MARGIN_MOBILE : IO_MARGIN_DESKTOP;
+    if (S.io && S.ioMargin === margin) return S.io;
+    // Si la marge doit changer (resize/orientation), on recrée l'observer.
+    if (S.io && S.ioMargin !== margin) {
+      try { S.io.disconnect(); } catch (_) {}
+      S.io = null;
+    }
+    S.ioMargin = margin;
     try {
       S.io = new IntersectionObserver(entries => {
         for (const e of entries) {
@@ -667,119 +427,86 @@ function recycleAndMove(klass, targetEl, newKey) {
           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 });
+      }, { root: null, rootMargin: margin, threshold: 0 });
     } catch (_) { S.io = null; }
     return S.io;
   }
 
   function observePh(id) {
-    const ph = phEl(id);
+    const ph = document.getElementById(`${PH_PREFIX}${id}`);
     if (ph?.isConnected) try { getIO()?.observe(ph); } catch (_) {}
-    // Fast-path : si déjà proche viewport, ne pas attendre un callback IO complet
-    try {
-      if (!ph?.isConnected) return;
-      const rect = ph.getBoundingClientRect();
-      const vh = window.innerHeight || 800;
-      const preload = isMobile() ? 1400 : 1000;
-      if (rect.top <= vh + preload && rect.bottom >= -preload) enqueueShow(id);
-    } catch (_) {}
   }
 
-function enqueueShow(id) {
-  if (!id || isBlocked()) return;
-  const n = parseInt(id, 10);
-  if (!Number.isFinite(n) || n <= 0) return;
-  if (ts() - (S.lastShow.get(n) ?? 0) < SHOW_THROTTLE_MS) return;
-  if (!S.pendingSet.has(n)) { S.pending.push(n); S.pendingSet.add(n); }
-  scheduleDrainQueue();
-}
-
-function scheduleDrainQueue() {
-  if (isBlocked()) return;
-  if (S.showBatchTimer) return;
-  S.showBatchTimer = setTimeout(() => {
-    S.showBatchTimer = 0;
-    drainQueue();
-  }, BATCH_FLUSH_MS);
-}
-
-function drainQueue() {
-  if (isBlocked()) return;
-  const free = Math.max(0, MAX_INFLIGHT - S.inflight);
-  if (!free || !S.pending.length) return;
-
-  const picked = [];
-  const seen = new Set();
-  const batchCap = Math.max(1, Math.min(MAX_SHOW_BATCH, free, getDynamicShowBatchMax()));
-  while (S.pending.length && picked.length < batchCap) {
-    const id = S.pending.shift();
-    S.pendingSet.delete(id);
-    if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-    if (!phEl(id)?.isConnected) continue;
-    seen.add(id);
-    picked.push(id);
+  function enqueueShow(id) {
+    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);
   }
-  if (picked.length) startShowBatch(picked);
-  if (S.pending.length && (MAX_INFLIGHT - S.inflight) > 0) scheduleDrainQueue();
-}
-
-function startShowBatch(ids) {
-  if (!ids?.length || isBlocked()) return;
-  const reserve = ids.length;
-  S.inflight += reserve;
-
-  let done = false;
-  const release = () => {
-    if (done) return;
-    done = true;
-    S.inflight = Math.max(0, S.inflight - reserve);
-    drainQueue();
-  };
-  const timer = setTimeout(release, SHOW_FAILSAFE_MS);
 
-  requestAnimationFrame(() => {
-    try {
-      if (isBlocked()) { clearTimeout(timer); return release(); }
+  function drainQueue() {
+    if (isBlocked()) return;
+    while (S.inflight < MAX_INFLIGHT && S.pending.length) {
+      const id = S.pending.shift();
+      S.pendingSet.delete(id);
+      startShow(id);
+    }
+  }
 
-      const valid = [];
-      const t = ts();
+  function startShow(id) {
+    if (!id || isBlocked()) return;
+    S.inflight++;
+    let done = false;
+    const release = () => {
+      if (done) return;
+      done = true;
+      S.inflight = Math.max(0, S.inflight - 1);
+      drainQueue();
+    };
+    const timer = setTimeout(release, 7000);
 
-      for (const raw of ids) {
-        const id = parseInt(raw, 10);
-        if (!Number.isFinite(id) || id <= 0) continue;
-        const ph = phEl(id);
-        if (!canShowPlaceholderId(id, t)) continue;
+    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 = 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 (_) {}
-        valid.push(id);
-      }
 
-      if (!valid.length) { clearTimeout(timer); return release(); }
+        // Horodater le show sur le wrap pour grace period + emptyCheck
+        try { ph.closest?.(`.${WRAP_CLASS}`)?.setAttribute(A_SHOWN, String(t)); } catch (_) {}
 
-      window.ezstandalone = window.ezstandalone || {};
-      const ez = window.ezstandalone;
-      const doShow = () => {
-        const prepared = destroyBeforeReuse(valid);
-        if (!prepared.length) { setTimeout(() => { clearTimeout(timer); release(); }, SHOW_RELEASE_MS); return; }
-        try { ez.showAds(...prepared); } catch (_) {}
-        for (const id of prepared) {
-          S.ezActiveIds.add(id);
-          S.ezShownSinceDestroy.add(id);
-        }
-        setTimeout(() => { clearTimeout(timer); release(); }, SHOW_RELEASE_MS);
-      };
-      Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
-    } catch (_) { clearTimeout(timer); release(); }
-  });
-}
+        window.ezstandalone = window.ezstandalone || {};
+        const ez = window.ezstandalone;
+        const doShow = () => {
+          try { ez.showAds(id); } catch (_) {}
+          scheduleEmptyCheck(id, t);
+          setTimeout(() => { clearTimeout(timer); release(); }, 700);
+        };
+        Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
+      } catch (_) { clearTimeout(timer); release(); }
+    });
+  }
 
+  function scheduleEmptyCheck(id, showTs) {
+    setTimeout(() => {
+      try {
+        const ph   = document.getElementById(`${PH_PREFIX}${id}`);
+        const wrap = ph?.closest?.(`.${WRAP_CLASS}`);
+        if (!wrap || !ph?.isConnected) return;
+        // Un show plus récent → ne pas toucher
+        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 = () => {
@@ -791,21 +518,14 @@ function startShowBatch(ids) {
         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;
-            if (!phEl(id)?.isConnected || !hasSinglePlaceholder(id)) continue;
+            if (!document.getElementById(`${PH_PREFIX}${id}`)?.isConnected) continue;
             seen.add(id);
-            valid.push(id);
-          }
-          if (!valid.length) return;
-          try { orig(...valid); } catch (_) {
-            for (const id of valid) {
-              try { orig(id); } catch (_) {}
-            }
+            try { orig(id); } catch (_) {}
           }
         };
       } catch (_) {}
@@ -817,12 +537,11 @@ function startShowBatch(ids) {
     }
   }
 
-  // ── Core ───────────────────────────────────────────────────────────────────
+  // ── Core run ───────────────────────────────────────────────────────────────
 
   async function runCore() {
     if (isBlocked()) return 0;
     patchShowAds();
-    sweepDeadWraps();
 
     const cfg = await fetchConfig();
     if (!cfg || cfg.excluded) return 0;
@@ -833,30 +552,30 @@ function startShowBatch(ids) {
 
     const exec = (klass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
       if (!normBool(cfgEnable)) return 0;
+      const items    = getItems();
       const interval = Math.max(1, parseInt(cfgInterval, 10) || 3);
-      return injectBetween(klass, getItems(), interval, normBool(cfgShowFirst), poolKey);
+      pruneOrphans(klass);
+      const n = injectBetween(klass, items, interval, normBool(cfgShowFirst), poolKey);
+      if (n) decluster(klass);
+      return n;
     };
 
     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(
+    if (kind === 'categoryTopics') return exec(
+      'ezoic-ad-between', getTopics,
+      cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics'
+    );
+    if (kind === 'categories') return exec(
       'ezoic-ad-categories', getCategories,
       cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories'
     );
+    return 0;
   }
 
-  // ── Scheduler ──────────────────────────────────────────────────────────────
+  // ── Scheduler / Burst ──────────────────────────────────────────────────────
 
   function scheduleRun(cb) {
     if (S.runQueued) return;
@@ -874,8 +593,10 @@ function startShowBatch(ids) {
     if (isBlocked()) return;
     const t = ts();
     if (t - S.lastBurstTs < BURST_COOLDOWN_MS) return;
-    S.lastBurstTs   = t;
-    S.pageKey       = pageKey();
+    S.lastBurstTs = t;
+
+    const pk = pageKey();
+    S.pageKey      = pk;
     S.burstDeadline = t + 2000;
 
     if (S.burstActive) return;
@@ -883,69 +604,49 @@ function startShowBatch(ids) {
     S.burstCount  = 0;
 
     const step = () => {
-      if (pageKey() !== S.pageKey || isBlocked() || ts() > S.burstDeadline || S.burstCount >= 8) {
+      if (pageKey() !== pk || isBlocked() || ts() > S.burstDeadline || S.burstCount >= 8) {
         S.burstActive = false; return;
       }
       S.burstCount++;
       scheduleRun(n => {
         if (!n && !S.pending.length) { S.burstActive = false; return; }
-        setTimeout(step, n > 0 ? 80 : 180);
+        setTimeout(step, n > 0 ? 150 : 300);
       });
     };
     step();
   }
 
-  // ── Cleanup navigation ─────────────────────────────────────────────────────
+  // ── Cleanup (navigation ajaxify) ───────────────────────────────────────────
 
   function cleanup() {
     blockedUntil = ts() + 1500;
     mutate(() => document.querySelectorAll(`.${WRAP_CLASS}`).forEach(dropWrap));
     S.cfg          = null;
-    S.poolsReady   = false;
+    S.poolSig       = null;
     S.pools        = { topics: [], posts: [], categories: [] };
     S.cursors      = { topics: 0, posts: 0, categories: 0 };
     S.mountedIds.clear();
     S.lastShow.clear();
-    S.wrapByKey.clear();
-    S.ezActiveIds.clear();
-    S.ezShownSinceDestroy.clear();
     S.inflight     = 0;
     S.pending      = [];
     S.pendingSet.clear();
-    if (S.showBatchTimer) { clearTimeout(S.showBatchTimer); S.showBatchTimer = 0; }
-    if (S.destroyBatchTimer) { clearTimeout(S.destroyBatchTimer); S.destroyBatchTimer = 0; }
-    S.destroyPending = [];
-    S.destroyPendingSet.clear();
     S.burstActive  = false;
     S.runQueued    = false;
-    S.sweepQueued   = false;
-    S.scrollSpeed  = 0;
-    S.lastScrollY  = 0;
-    S.lastScrollTs = 0;
   }
 
-  // ── MutationObserver ───────────────────────────────────────────────────────
+  // ── DOM Observer ───────────────────────────────────────────────────────────
 
   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;
       for (const m of muts) {
-        let sawWrapRemoval = false;
-        for (const n of m.removedNodes) {
-          if (n.nodeType !== 1) continue;
-          if ((n.matches && n.matches(`.${WRAP_CLASS}`)) || (n.querySelector && n.querySelector(`.${WRAP_CLASS}`))) {
-            sawWrapRemoval = true;
-          }
-        }
-        if (sawWrapRemoval) queueSweepDeadWraps();
+        if (!m.addedNodes?.length) continue;
         for (const n of m.addedNodes) {
           if (n.nodeType !== 1) continue;
-          try { healFalseEmpty(n); } catch (_) {}
-          // 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;} })) {
+          if (n.matches?.(SEL.post)     || n.querySelector?.(SEL.post)     ||
+              n.matches?.(SEL.topic)    || n.querySelector?.(SEL.topic)    ||
+              n.matches?.(SEL.category) || n.querySelector?.(SEL.category)) {
             requestBurst(); return;
           }
         }
@@ -959,14 +660,7 @@ function startShowBatch(ids) {
   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}`,
-    ];
+    const MUTED = ['[EzoicAds JS]: Placeholder Id', '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;
@@ -978,18 +672,29 @@ function startShowBatch(ids) {
   }
 
   function ensureTcfLocator() {
+    // Le CMP utilise une iframe nommée __tcfapiLocator pour router les
+    // postMessage TCF. En navigation ajaxify, NodeBB peut retirer cette
+    // iframe du DOM (vidage partiel du body), ce qui provoque :
+    //   "Cannot read properties of null (reading 'postMessage')"
+    //   "Cannot set properties of null (setting 'addtlConsent')"
+    // Solution : la recrée immédiatement si elle disparaît, via un observer.
     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();
+
+      // Observer dédié — si quelqu'un retire l'iframe, on la remet.
       if (!window.__nbbTcfObs) {
-        window.__nbbTcfObs = new MutationObserver(inject);
-        window.__nbbTcfObs.observe(document.documentElement, { childList: true, subtree: true });
+        window.__nbbTcfObs = new MutationObserver(() => inject());
+        window.__nbbTcfObs.observe(document.documentElement,
+          { childList: true, subtree: true });
       }
     } catch (_) {}
   }
@@ -999,10 +704,10 @@ function startShowBatch(ids) {
     const head = document.head;
     if (!head) return;
     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 ],
+      ['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],
     ]) {
@@ -1016,7 +721,7 @@ function startShowBatch(ids) {
     }
   }
 
-  // ── Bindings ───────────────────────────────────────────────────────────────
+  // ── Bindings NodeBB ────────────────────────────────────────────────────────
 
   function bindNodeBB() {
     const $ = window.jQuery;
@@ -1027,16 +732,19 @@ function startShowBatch(ids) {
     $(window).on('action:ajaxify.end.nbbEzoic', () => {
       S.pageKey    = pageKey();
       blockedUntil = 0;
-      muteConsole(); ensureTcfLocator(); warmNetwork();
-      patchShowAds(); getIO(); ensureDomObserver(); sweepDeadWraps(); requestBurst();
+      muteConsole(); ensureTcfLocator(); warmNetwork(); patchShowAds();
+      getIO(); ensureDomObserver(); requestBurst();
     });
 
-    const burstEvts = [
-      'action:ajaxify.contentLoaded', 'action:posts.loaded', 'action:topics.loaded',
+    const BURST_EVENTS = [
+      '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(); });
 
+    $(window).on(BURST_EVENTS, () => { if (!isBlocked()) requestBurst(); });
+
+    // Hooks AMD (NodeBB 4.x — redondant avec jQuery events mais sans risque)
     try {
       require(['hooks'], hooks => {
         if (typeof hooks?.on !== 'function') return;
@@ -1048,24 +756,25 @@ function startShowBatch(ids) {
     } catch (_) {}
   }
 
+
+  function bindResize() {
+    let t = null;
+    window.addEventListener('resize', () => {
+      clearTimeout(t);
+      t = setTimeout(() => {
+        try { getIO(); } catch (_) {}
+        // Ré-observer les placeholders existants (si IO recréé)
+        try {
+          document.querySelectorAll(`.${WRAP_CLASS} [id^="${PH_PREFIX}"]`).forEach(ph => {
+            if (ph instanceof Element) { try { S.io?.observe(ph); } catch (_) {} }
+          });
+        } catch (_) {}
+      }, 200);
+    }, { passive: true });
+  }
   function bindScroll() {
     let ticking = false;
-    try {
-      S.lastScrollY = window.scrollY || window.pageYOffset || 0;
-      S.lastScrollTs = ts();
-    } catch (_) {}
     window.addEventListener('scroll', () => {
-      try {
-        const y = window.scrollY || window.pageYOffset || 0;
-        const t = ts();
-        const dy = y - (S.lastScrollY || 0);
-        const dt = Math.max(1, t - (S.lastScrollTs || t));
-        if (Math.abs(dy) > 1) S.scrollDir = dy >= 0 ? 1 : -1;
-        const inst = Math.abs(dy) * 1000 / dt;
-        S.scrollSpeed = S.scrollSpeed ? (S.scrollSpeed * 0.7 + inst * 0.3) : inst;
-        S.lastScrollY = y;
-        S.lastScrollTs = t;
-      } catch (_) {}
       if (ticking) return;
       ticking = true;
       requestAnimationFrame(() => { ticking = false; requestBurst(); });
@@ -1082,6 +791,7 @@ function startShowBatch(ids) {
   getIO();
   ensureDomObserver();
   bindNodeBB();
+  bindResize();
   bindScroll();
   blockedUntil = 0;
   requestBurst();