nodebb-plugin-ezoic-infinite 1.7.12 → 1.7.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.7.12",
+  "version": "1.7.13",
   "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",

package/public/client.js

@@ -1,38 +1,57 @@
 /**
  * NodeBB Ezoic Infinite Ads — client.js v23
  *
- * v20  Table KIND : anchorAttr par kindClass. Fix catégories (data-cid).
- *      IO fixe une seule instance. Burst cooldown 200ms.
- * v22  Fix ordinal fallback posts (baseTag vide cassait :scope>). isFilled guard pruneOrphans.
- * v23  Fix "pubs écrasées" : INJECT_GRACE_MS protège les wraps non encore fills.
- *      decluster : ne supprime jamais un wrap filled, grace basée sur A_CREATED aussi.
- *      KIND table : baseTag explicite (évite le split fragile).
- *      wrapByKey Map O(1) pour findWrap. poolsReady (initPools une fois/page).
- *      patchShowAds sorti du hot path runCore. wrapByKey sync sur dropWrap/cleanup.
+ * 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).
+ *
+ * [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.
+ *
+ * [BUG] injectBetween : `break` sur pool épuisé empêchait d'observer les wraps
+ *   existants sur les items suivants. Fix : `continue` au lieu de `break`.
+ *
+ * [PERF] IntersectionObserver recréé à chaque scroll boost → très coûteux mobile.
+ *   Fix : marge large fixe par device, observer créé une seule fois.
+ *
+ * [PERF] Burst cooldown 100ms trop court sur mobile → rafales en cascade.
+ *   Fix : 200ms.
+ *
+ * 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 () {
   '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
-
-  const MIN_PRUNE_AGE_MS    = 8_000;  // délai avant qu'un wrap puisse être purgé
-  const INJECT_GRACE_MS     = 30_000; // fenêtre post-injection : wrap non supprimable (fill async en cours)
-  const FILL_GRACE_MS       = 25_000; // fenêtre post-showAds pour decluster
-  const EMPTY_CHECK_MS      = 20_000; // délai avant de marquer un wrap vide
+  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;
 
-  const IO_MARGIN_DESKTOP   = '2500px 0px 2500px 0px';
-  const IO_MARGIN_MOBILE    = '3500px 0px 3500px 0px';
+  // 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';
 
   const SEL = {
     post:     '[component="post"][data-pid]',
@@ -41,53 +60,50 @@
   };
 
   /**
-   * Table KIND — source de vérité par kindClass.
+   * Table centrale : kindClass → { selector DOM, attribut d'ancre stable }
    *
-   * anchorAttr : attribut DOM stable → clé unique du wrap
-   *   data-pid   posts      (id message, immuable)
-   *   data-index topics     (index dans la liste)
-   *   data-cid   catégories (id catégorie, immuable)
-   * baseTag : préfixe tag pour le querySelector d'ancre dans pruneOrphans.
-   *   Vide pour posts (sélecteur sans tag). Explicite pour éviter le split fragile.
+   * 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,     anchorAttr: 'data-pid',   baseTag: ''   },
-    'ezoic-ad-between':    { sel: SEL.topic,    anchorAttr: 'data-index', baseTag: 'li' },
-    'ezoic-ad-categories': { sel: SEL.category, anchorAttr: 'data-cid',   baseTag: 'li' },
+    '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 ───────────────────────────────────────────────────────────────────
 
   const S = {
-    pageKey:       null,
-    cfg:           null,
-    pools:         { topics: [], posts: [], categories: [] },
-    cursors:       { topics: 0,  posts: 0,  categories: 0  },
-    mountedIds:    new Set(),  // IDs Ezoic dans le DOM
-    lastShow:      new Map(),  // id → timestamp dernier show
-    io:            null,
-    domObs:        null,
-    mutGuard:      0,
-    inflight:      0,
-    pending:       [],
-    pendingSet:    new Set(),
-    runQueued:     false,
-    burstActive:   false,
+    pageKey: null,
+    cfg: 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,
+    domObs:  null,
+    mutGuard: 0,                // compteur internalMutation
+
+    inflight:    0,
+    pending:     [],
+    pendingSet:  new Set(),
+
+    runQueued:    false,
+    burstActive:  false,
     burstDeadline: 0,
-    burstCount:    0,
-    lastBurstTs:   0,
+    burstCount:   0,
+    lastBurstTs:  0,
   };
 
-  // Map anchorKey → wrap Element — lookup O(1) au lieu de querySelector full-DOM
-  const wrapByKey  = new Map();
-  let   blockedUntil = 0;
-  let   poolsReady   = false; // initPools une seule fois par page
-
-  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]'));
+  let blockedUntil = 0;
+  const isBlocked  = () => Date.now() < blockedUntil;
+  const ts         = () => Date.now();
 
   function mutate(fn) {
     S.mutGuard++;
@@ -105,6 +121,12 @@
     return S.cfg;
   }
 
+  function initPools(cfg) {
+    S.pools.topics     = parseIds(cfg.placeholderIds);
+    S.pools.posts      = parseIds(cfg.messagePlaceholderIds);
+    S.pools.categories = parseIds(cfg.categoryPlaceholderIds);
+  }
+
   function parseIds(raw) {
     const out = [], seen = new Set();
     for (const v of String(raw || '').split(/\r?\n/).map(s => s.trim()).filter(Boolean)) {
@@ -114,13 +136,12 @@
     return out;
   }
 
-  function initPools(cfg) {
-    if (poolsReady) return;
-    S.pools.topics     = parseIds(cfg.placeholderIds);
-    S.pools.posts      = parseIds(cfg.messagePlaceholderIds);
-    S.pools.categories = parseIds(cfg.categoryPlaceholderIds);
-    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 ──────────────────────────────────────────────────────────
 
@@ -144,13 +165,13 @@
     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';
     });
@@ -166,29 +187,38 @@
     );
   }
 
-  // ── Ancres stables ─────────────────────────────────────────────────────────
+  // ── Ancres stables ────────────────────────────────────────────────────────
 
-  function stableId(klass, el) {
-    const attr = KIND[klass]?.anchorAttr;
+  /**
+   * 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(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 makeAnchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
 
-  function findWrap(key) {
-    const w = wrapByKey.get(key);
-    if (w && w.isConnected) return w;
-    if (w) wrapByKey.delete(key); // nettoyage lazy si wrap retiré hors de notre contrôle
-    return null;
+  function findWrap(anchorKey) {
+    try {
+      return document.querySelector(
+        `.${WRAP_CLASS}[${A_ANCHOR}="${anchorKey.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"]`
+      );
+    } catch (_) { return null; }
   }
 
   // ── Pool ───────────────────────────────────────────────────────────────────
@@ -196,7 +226,7 @@
   function pickId(poolKey) {
     const pool = S.pools[poolKey];
     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;
@@ -221,14 +251,13 @@
   }
 
   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);
-    wrapByKey.set(key, w);
     return w;
   }
 
@@ -236,9 +265,9 @@
     try {
       const id = parseInt(w.getAttribute(A_WRAPID), 10);
       if (Number.isFinite(id)) S.mountedIds.delete(id);
-      const key = w.getAttribute(A_ANCHOR);
-      if (key) wrapByKey.delete(key);
-      // unobserve avant remove — guard instanceof (unobserve(null) corrompt l'IO pubads)
+      // 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);
@@ -250,58 +279,65 @@
   // ── Prune ──────────────────────────────────────────────────────────────────
 
   /**
-   * Supprime les wraps VIDES dont l'ancre a disparu du DOM.
+   * 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
    *
-   * Protections :
-   *  1. Pas avant MIN_PRUNE_AGE_MS (DOM post-batch pas encore stabilisé)
-   *  2. Jamais si filled (pub affichée — SDK Ezoic a des callbacks async dessus)
-   *  3. Pas avant INJECT_GRACE_MS depuis création (fill Ezoic peut être très async)
+   * On ne prune pas les wraps < MIN_PRUNE_AGE_MS (DOM pas encore stabilisé).
    */
   function pruneOrphans(klass) {
     const meta = KIND[klass];
     if (!meta) return;
 
-    for (const w of document.querySelectorAll(`.${WRAP_CLASS}.${klass}`)) {
-      const age = ts() - parseInt(w.getAttribute(A_CREATED) || '0', 10);
-      if (age < MIN_PRUNE_AGE_MS)  continue;
-      if (isFilled(w))             continue;
-      if (age < INJECT_GRACE_MS)   continue;
+    // baseTag déduit du sélecteur : 'li' pour topics/catégories, '' pour posts.
+    // Pour les posts (baseTag=''), on cherche juste [data-pid="X"] sans préfixe
+    // — c'est correct car data-pid est unique dans le DOM.
+    const baseTag = meta.sel.split('[')[0];
+
+    document.querySelectorAll(`.${WRAP_CLASS}.${klass}`).forEach(w => {
+      if (ts() - parseInt(w.getAttribute(A_CREATED) || '0', 10) < MIN_PRUNE_AGE_MS) return;
+      if (isFilled(w)) return; // jamais supprimer un wrap rempli
 
       const key = w.getAttribute(A_ANCHOR) ?? '';
       const sid = key.slice(klass.length + 1);
-      if (!sid) { mutate(() => dropWrap(w)); continue; }
+      if (!sid) { mutate(() => dropWrap(w)); return; }
 
-      const sel      = `${meta.baseTag}[${meta.anchorAttr}="${sid.replace(/"/g, '\\"')}"]`;
-      const anchorEl = document.querySelector(sel);
+      const anchorEl = document.querySelector(
+        `${baseTag}[${meta.anchorAttr}="${sid.replace(/"/g, '\\"')}"]`
+      );
       if (!anchorEl || !anchorEl.isConnected) mutate(() => dropWrap(w));
-    }
+    });
   }
 
   // ── Decluster ──────────────────────────────────────────────────────────────
 
   /**
-   * Deux wraps adjacents → supprimer le moins prioritaire.
-   *
+   * Deux wraps adjacents = situation anormale → supprimer le moins prioritaire.
    * Règles absolues :
-   *  - Jamais supprimer un wrap filled
-   *  - Jamais supprimer un wrap < INJECT_GRACE_MS (fill Ezoic potentiellement en cours)
-   *  - Jamais supprimer un wrap < FILL_GRACE_MS depuis le dernier showAds
-   *  - Si les deux wraps adjacents sont vides et hors grâce → supprimer le courant
+   *  - Jamais supprimer un wrap filled (pub affichée)
+   *  - Jamais supprimer un wrap < FILL_GRACE_MS depuis création OU depuis showAds
+   *    (le fill Ezoic est async : l'enchère SSP peut prendre plusieurs secondes
+   *     après showAds, et showAds lui-même peut arriver bien après l'injection)
+   *  - Si les deux sont filled → on ne touche rien
    */
   function decluster(klass) {
     for (const w of document.querySelectorAll(`.${WRAP_CLASS}.${klass}`)) {
-      if (isFilled(w)) continue;
-      const wAge   = ts() - parseInt(w.getAttribute(A_CREATED) || '0', 10);
-      if (wAge < INJECT_GRACE_MS) continue;
+      if (isFilled(w)) continue; // filled = intouchable
+      const wCreated = parseInt(w.getAttribute(A_CREATED) || '0', 10);
+      if (ts() - wCreated < FILL_GRACE_MS) continue; // trop récent
       const wShown = parseInt(w.getAttribute(A_SHOWN) || '0', 10);
-      if (wShown && ts() - wShown < FILL_GRACE_MS) continue;
+      if (wShown && ts() - wShown < FILL_GRACE_MS) continue; // showAds récent
 
       let prev = w.previousElementSibling, steps = 0;
       while (prev && steps++ < 3) {
         if (!prev.classList?.contains(WRAP_CLASS)) { prev = prev.previousElementSibling; continue; }
-        if (isFilled(prev)) break;
-        const pAge   = ts() - parseInt(prev.getAttribute(A_CREATED) || '0', 10);
-        if (pAge < INJECT_GRACE_MS) break;
+        if (isFilled(prev)) break; // précédent filled = intouchable
+        const pCreated = parseInt(prev.getAttribute(A_CREATED) || '0', 10);
+        if (ts() - pCreated < FILL_GRACE_MS) break;
         const pShown = parseInt(prev.getAttribute(A_SHOWN) || '0', 10);
         if (pShown && ts() - pShown < FILL_GRACE_MS) break;
 
@@ -316,13 +352,14 @@
 
   /**
    * Ordinal 0-based pour le calcul de l'intervalle.
-   * Posts/topics : data-index (NodeBB 4.x).
-   * Catégories   : fallback positionnel (page statique, pas d'infinite scroll).
+   * 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 di = el.getAttribute('data-index');
     if (di !== null && di !== '' && !isNaN(di)) return parseInt(di, 10);
-    // Fallback — s.matches(fullSel) pour ne pas compter les wraps intercalés
+    // Fallback positionnel — filtre par sélecteur complet pour éviter le bug
+    // baseTag='' (posts) où `:scope > ` sans tag ne fonctionne pas.
     const fullSel = KIND[klass]?.sel ?? '';
     let i = 0;
     for (const s of el.parentElement?.children ?? []) {
@@ -340,16 +377,17 @@
       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 = makeAnchorKey(klass, el);
-      if (findWrap(key)) continue;
+      if (findWrap(key)) continue; // déjà là → pas de pickId inutile
 
       const id = pickId(poolKey);
-      if (!id) continue;
+      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++; }
@@ -361,6 +399,7 @@
 
   function getIO() {
     if (S.io) return S.io;
+    const margin = isMobile() ? IO_MARGIN_MOBILE : IO_MARGIN_DESKTOP;
     try {
       S.io = new IntersectionObserver(entries => {
         for (const e of entries) {
@@ -369,7 +408,7 @@
           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;
   }
@@ -420,6 +459,7 @@
         if (t - (S.lastShow.get(id) ?? 0) < SHOW_THROTTLE_MS) { clearTimeout(timer); return release(); }
         S.lastShow.set(id, t);
 
+        // 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 || {};
@@ -440,6 +480,7 @@
         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 (_) {}
@@ -458,7 +499,7 @@
         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 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);
@@ -477,10 +518,11 @@
     }
   }
 
-  // ── Core ───────────────────────────────────────────────────────────────────
+  // ── Core run ───────────────────────────────────────────────────────────────
 
   async function runCore() {
     if (isBlocked()) return 0;
+    patchShowAds();
 
     const cfg = await fetchConfig();
     if (!cfg || cfg.excluded) return 0;
@@ -491,9 +533,10 @@
 
     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);
       pruneOrphans(klass);
-      const n = injectBetween(klass, getItems(), interval, normBool(cfgShowFirst), poolKey);
+      const n = injectBetween(klass, items, interval, normBool(cfgShowFirst), poolKey);
       if (n) decluster(klass);
       return n;
     };
@@ -534,7 +577,7 @@
     S.lastBurstTs = t;
 
     const pk = pageKey();
-    S.pageKey       = pk;
+    S.pageKey      = pk;
     S.burstDeadline = t + 2000;
 
     if (S.burstActive) return;
@@ -554,13 +597,11 @@
     step();
   }
 
-  // ── Cleanup navigation ─────────────────────────────────────────────────────
+  // ── Cleanup (navigation ajaxify) ───────────────────────────────────────────
 
   function cleanup() {
     blockedUntil = ts() + 1500;
-    poolsReady   = false;
     mutate(() => document.querySelectorAll(`.${WRAP_CLASS}`).forEach(dropWrap));
-    wrapByKey.clear();
     S.cfg          = null;
     S.pools        = { topics: [], posts: [], categories: [] };
     S.cursors      = { topics: 0, posts: 0, categories: 0 };
@@ -577,14 +618,15 @@
 
   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) {
         if (!m.addedNodes?.length) continue;
         for (const n of m.addedNodes) {
           if (n.nodeType !== 1) continue;
-          if (allSel.some(s => n.matches?.(s) || n.querySelector?.(s))) {
+          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;
           }
         }
@@ -610,20 +652,29 @@
   }
 
   function ensureTcfLocator() {
-    // L'iframe __tcfapiLocator route les appels postMessage du CMP.
-    // En navigation ajaxify, NodeBB peut la retirer → erreurs CMP.
+    // 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 (_) {}
   }
@@ -633,10 +684,10 @@
     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],
     ]) {
@@ -670,8 +721,10 @@
       'action:posts.loaded', 'action:topics.loaded',
       'action:categories.loaded', 'action:category.loaded', 'action:topic.loaded',
     ].map(e => `${e}.nbbEzoic`).join(' ');
+
     $(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;