nodebb-plugin-ezoic-infinite 1.7.0 → 1.7.2

package/public/client.js

@@ -1,459 +1,419 @@
 /**
- * NodeBB Ezoic Infinite Ads — client.js (v19)
+ * NodeBB Ezoic Infinite Ads — client.js (v20)
  *
- * Correctifs v19 vs v18 :
+ * 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 1] Pubs regroupées en haut après scroll up/down
- *    Cause : pruneOrphans gardait les wraps "filled" même quand leur ancre DOM
- *    avait disparu (post virtualisé). Ces wraps sans parent flottaient et
- *    NodeBB les réordonnait arbitrairement.
- *    Fix : un wrap dont l'ancre est absente du DOM EST supprimé, rempli ou non.
- *    Exception : si l'ancre est simplement hors-viewport mais still connected
- *    (NodeBB ne virtualise pas toujours le DOM), on la conserve.
+ * [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 2] Pub qui apparaît puis disparaît
- *    Cause : decluster() supprimait un wrap "vide" pendant la fenêtre de fill
- *    async d'Ezoic. Le guard TTL de 90s était calculé depuis la création,
- *    mais le show() peut avoir été appelé bien après la création.
- *    Fix : on ajoute data-ezoic-shown (timestamp du show). decluster ne touche
- *    pas un wrap dont le show date de moins de FILL_GRACE_MS (20s).
+ * [BUG] injectBetween : `break` sur pool épuisé empêchait d'observer les wraps
+ *   existants sur les items suivants. Fix : `continue` au lieu de `break`.
  *
- *  [BUG 3] Intervalle 1/x non respecté sur infinite scroll
- *    Cause : computeTargetIndices utilisait l'index dans le tableau courant
- *    (items[0..N]), qui recommence à 0 à chaque batch de posts chargés.
- *    Fix : on utilise l'ordinal GLOBAL du post (data-index fourni par NodeBB,
- *    ou data-pid comme fallback numérique). L'intervalle est appliqué sur cet
- *    ordinal global → pub tous les X posts absolus, quel que soit le batch.
+ * [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';
 
-  // ─── Constants ────────────────────────────────────────────────────────────
-  const WRAP_CLASS         = 'nodebb-ezoic-wrap';
-  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
-  const ANCHOR_ATTR        = 'data-ezoic-anchor';   // "kindClass:globalOrdinal"
-  const WRAPID_ATTR        = 'data-ezoic-wrapid';   // ezoic placeholder id
-  const CREATED_ATTR       = 'data-ezoic-created';  // timestamp création
-  const SHOWN_ATTR         = 'data-ezoic-shown';    // timestamp dernier showAds
+  // ── 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 (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;
-  // Après un showAds(), ne pas decluster pendant ce délai (fill async Ezoic)
-  const FILL_GRACE_MS       = 20_000;
-  // Collapse is-empty seulement après ce délai post-show
-  const EMPTY_CHECK_DELAY   = 18_000;
-
-  const PRELOAD_MARGIN = {
-    desktop:        '2000px 0px 2000px 0px',
-    mobile:         '3000px 0px 3000px 0px',
-    desktopBoosted: '4500px 0px 4500px 0px',
-    mobileBoosted:  '4500px 0px 4500px 0px',
-  };
-  const BOOST_DURATION_MS     = 2500;
-  const BOOST_SPEED_PX_PER_MS = 2.2;
-  const MAX_INFLIGHT_DESKTOP  = 4;
-  const MAX_INFLIGHT_MOBILE   = 3;
-  const SHOW_THROTTLE_MS      = 900;
-
-  const SELECTORS = {
-    topicItem:    'li[component="category/topic"]',
-    postItem:     '[component="post"][data-pid]',
-    categoryItem: 'li[component="categories/category"]',
+  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';
+
+  const SEL = {
+    post:     '[component="post"][data-pid]',
+    topic:    'li[component="category/topic"]',
+    category: 'li[component="categories/category"]',
   };
 
-  // ─── Helpers ──────────────────────────────────────────────────────────────
-  const now     = () => Date.now();
-  const isMobile = () => { try { return window.innerWidth < 768; } catch (_) { return false; } };
-  const normBool = (v) => v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
-  const isFilledNode = (n) => !!(n?.querySelector?.('iframe, ins, img, video, [data-google-container-id]'));
+  /**
+   * Table centrale : kindClass → { selector DOM, attribut d'ancre stable }
+   *
+   * 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'   },
+    'ezoic-ad-between':    { sel: SEL.topic,    anchorAttr: 'data-index' },
+    'ezoic-ad-categories': { sel: SEL.category, anchorAttr: 'data-cid'   },
+  };
 
-  function uniqInts(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 (Number.isFinite(n) && n > 0 && !seen.has(n)) { seen.add(n); out.push(n); }
-    }
-    return out;
-  }
+  // ── État ───────────────────────────────────────────────────────────────────
 
-  // ─── State ────────────────────────────────────────────────────────────────
-  const state = {
+  const S = {
     pageKey: null,
     cfg: null,
 
-    pools:   { topics: [], posts: [], categories: [] },
-    cursors: { topics: 0,  posts: 0,  categories: 0  },
-
-    // IDs Ezoic actuellement montés dans le DOM (Set<number>)
-    mountedIds: new Set(),
-
-    lastShowById: new Map(),
+    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
 
-    domObs: null,
-    io: null, ioMargin: null,
+    io:      null,
+    domObs:  null,
+    mutGuard: 0,                // compteur internalMutation
 
-    internalMutation: 0,
+    inflight:    0,
+    pending:     [],
+    pendingSet:  new Set(),
 
-    inflight: 0,
-    pending: [], pendingSet: new Set(),
-
-    scrollBoostUntil: 0,
-    lastScrollY: 0, lastScrollTs: 0,
-
-    runQueued: false,
-    burstActive: false, burstDeadline: 0,
-    burstCount: 0, lastBurstReqTs: 0,
+    runQueued:    false,
+    burstActive:  false,
+    burstDeadline: 0,
+    burstCount:   0,
+    lastBurstTs:  0,
   };
 
   let blockedUntil = 0;
-  const isBlocked = () => now() < blockedUntil;
-  const isBoosted = () => now() < state.scrollBoostUntil;
+  const isBlocked  = () => Date.now() < blockedUntil;
+  const ts         = () => Date.now();
 
-  function withInternalMutation(fn) {
-    state.internalMutation++;
-    try { fn(); } finally { state.internalMutation--; }
+  function mutate(fn) {
+    S.mutGuard++;
+    try { fn(); } finally { S.mutGuard--; }
   }
 
-  // ─── Config ───────────────────────────────────────────────────────────────
+  // ── Config ─────────────────────────────────────────────────────────────────
+
   async function fetchConfig() {
-    if (state.cfg) return state.cfg;
+    if (S.cfg) return S.cfg;
     try {
-      const res = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
-      if (!res.ok) return null;
-      state.cfg = await res.json();
-    } catch (_) { state.cfg = null; }
-    return state.cfg;
+      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 initPools(cfg) {
-    if (!cfg) return;
-    // Réinitialise à chaque page (cleanup() remet les curseurs à 0)
-    state.pools.topics     = uniqInts(cfg.placeholderIds);
-    state.pools.posts      = uniqInts(cfg.messagePlaceholderIds);
-    state.pools.categories = uniqInts(cfg.categoryPlaceholderIds);
+    S.pools.topics     = parseIds(cfg.placeholderIds);
+    S.pools.posts      = parseIds(cfg.messagePlaceholderIds);
+    S.pools.categories = parseIds(cfg.categoryPlaceholderIds);
   }
 
-  // ─── Page / Kind ──────────────────────────────────────────────────────────
-  function getPageKey() {
+  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;
+  }
+
+  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 ──────────────────────────────────────────────────────────
+
+  function pageKey() {
     try {
-      const ax = window.ajaxify?.data;
-      if (ax?.tid) return `topic:${ax.tid}`;
-      if (ax?.cid) return `cid:${ax.cid}:${location.pathname}`;
+      const d = window.ajaxify?.data;
+      if (d?.tid) return `t:${d.tid}`;
+      if (d?.cid) return `c:${d.cid}`;
     } catch (_) {}
     return location.pathname;
   }
 
   function getKind() {
     const p = location.pathname;
-    if (/^\/topic\//.test(p))                      return 'topic';
-    if (/^\/category\//.test(p))                   return 'categoryTopics';
-    if (p === '/' || /^\/categories/.test(p))      return 'categories';
-    if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
-    if (document.querySelector(SELECTORS.postItem))     return 'topic';
-    if (document.querySelector(SELECTORS.topicItem))    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.category)) return 'categories';
+    if (document.querySelector(SEL.post))     return 'topic';
+    if (document.querySelector(SEL.topic))    return 'categoryTopics';
     return 'other';
   }
 
-  // ─── DOM helpers ──────────────────────────────────────────────────────────
-  function getPostContainers() {
-    return Array.from(document.querySelectorAll(SELECTORS.postItem)).filter(el => {
+  // ── 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 parent = el.parentElement?.closest('[component="post"][data-pid]');
-      if (parent && parent !== el) return false;
-      if (el.getAttribute('component') === 'post/parent') return false;
-      return true;
+      const p = el.parentElement?.closest('[component="post"][data-pid]');
+      if (p && p !== el) return false;
+      return el.getAttribute('component') !== 'post/parent';
     });
   }
 
-  function getTopicItems()    { return Array.from(document.querySelectorAll(SELECTORS.topicItem));    }
-  function getCategoryItems() { return Array.from(document.querySelectorAll(SELECTORS.categoryItem)); }
+  const getTopics     = () => Array.from(document.querySelectorAll(SEL.topic));
+  const getCategories = () => Array.from(document.querySelectorAll(SEL.category));
 
-  function hasAdjacentWrap(el) {
-    return !!(el.nextElementSibling?.classList?.contains(WRAP_CLASS) ||
-              el.previousElementSibling?.classList?.contains(WRAP_CLASS));
+  function adjacentWrap(el) {
+    return !!(
+      el.nextElementSibling?.classList?.contains(WRAP_CLASS) ||
+      el.previousElementSibling?.classList?.contains(WRAP_CLASS)
+    );
   }
 
-  // ─── Ordinal global (BUG FIX #3) ──────────────────────────────────────────
+  // ── Ancres stables ────────────────────────────────────────────────────────
+
   /**
-   * Retourne l'ordinal ABSOLU d'un élément dans la page complète (pas le batch).
-   *
-   * Pour les posts (topic) : NodeBB expose data-index (0-based) sur chaque
-   *   [component="post"]. On l'utilise directement.
-   *
-   * Pour les topics (liste catégorie) : idem, data-index sur le <li>.
-   *
-   * Fallback : on parcourt le DOM pour compter la position réelle de l'élément
-   * parmi ses frères de même type.
+   * 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 getGlobalOrdinal(el, selector) {
-    // 1. data-index (NodeBB 3+/4+) — 0-based → on retourne 1-based
-    const di = el.getAttribute('data-index');
-    if (di !== null && di !== '' && !isNaN(di)) return parseInt(di, 10); // déjà 0-based, on le garde
-
-    // 2. Compter dans le DOM parmi les frères du même type
+  function stableId(kindClass, el) {
+    const attr = KIND[kindClass]?.anchorAttr;
+    if (attr) {
+      const v = el.getAttribute(attr);
+      if (v !== null && v !== '') return v;
+    }
+    // Fallback : position dans le parent
     try {
-      const all = el.parentElement?.querySelectorAll?.(':scope > ' + selector.split('[')[0]);
-      if (all) {
-        let i = 0;
-        for (const node of all) {
-          if (node === el) return i;
-          i++;
-        }
+      let i = 0;
+      for (const s of el.parentElement?.children ?? []) {
+        if (s === el) return `i${i}`;
+        i++;
       }
     } catch (_) {}
-
-    return 0;
+    return 'i0';
   }
 
-  /**
-   * Clé d'ancre unique et stable pour un élément donné.
-   * Format : "kindClass:globalOrdinal"
-   * → Identique au scroll up/down, identique entre batches.
-   */
-  function getAnchorKey(kindClass, el, selector) {
-    const ord = getGlobalOrdinal(el, selector);
-    return `${kindClass}:${ord}`;
-  }
+  const makeAnchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
 
-  function findWrapByAnchor(anchorKey) {
-    // CSS.escape pour les : dans la clé
+  function findWrap(anchorKey) {
     try {
-      return document.querySelector(`.${WRAP_CLASS}[${ANCHOR_ATTR}="${anchorKey.replace(/"/g, '\\"')}"]`);
+      return document.querySelector(
+        `.${WRAP_CLASS}[${A_ANCHOR}="${anchorKey.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"]`
+      );
     } catch (_) { return null; }
   }
 
-  // ─── Pool rotation ────────────────────────────────────────────────────────
+  // ── Pool ───────────────────────────────────────────────────────────────────
+
   function pickId(poolKey) {
-    const pool = state.pools[poolKey];
-    if (!pool.length) return null;
-    for (let tries = 0; tries < pool.length; tries++) {
-      const idx = state.cursors[poolKey] % pool.length;
-      state.cursors[poolKey] = (state.cursors[poolKey] + 1) % pool.length;
-      const id = pool[idx];
-      if (!state.mountedIds.has(id)) return id;
+    const pool = S.pools[poolKey];
+    for (let t = 0; t < pool.length; t++) {
+      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;
     }
     return null;
   }
 
-  // ─── Wrap build / insert / remove ─────────────────────────────────────────
-  function buildWrap(id, kindClass, anchorKey) {
-    const wrap = document.createElement('div');
-    wrap.className = `${WRAP_CLASS} ${kindClass}`;
-    wrap.setAttribute(ANCHOR_ATTR, anchorKey);
-    wrap.setAttribute(WRAPID_ATTR, String(id));
-    wrap.setAttribute(CREATED_ATTR, String(now()));
-    wrap.style.cssText = 'width:100%;display:block;';
+  // ── Wraps DOM ──────────────────────────────────────────────────────────────
 
+  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(ts()));
+    w.style.cssText = 'width:100%;display:block;';
     const ph = document.createElement('div');
-    ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+    ph.id = `${PH_PREFIX}${id}`;
     ph.setAttribute('data-ezoic-id', String(id));
-    wrap.appendChild(ph);
-    return wrap;
+    w.appendChild(ph);
+    return w;
   }
 
-  function insertWrapAfter(el, id, kindClass, anchorKey) {
+  function insertAfter(el, id, klass, key) {
     if (!el?.insertAdjacentElement) return null;
-    if (findWrapByAnchor(anchorKey)) return null;  // déjà inséré
-    if (state.mountedIds.has(id))   return null;   // id déjà monté
-    if (document.getElementById(`${PLACEHOLDER_PREFIX}${id}`)?.isConnected) return null;
-
-    const wrap = buildWrap(id, kindClass, anchorKey);
-    withInternalMutation(() => el.insertAdjacentElement('afterend', wrap));
-    state.mountedIds.add(id);
-    return wrap;
+    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);
+    return w;
   }
 
-  function removeWrap(wrap) {
+  function dropWrap(w) {
     try {
-      const id = parseInt(wrap.getAttribute(WRAPID_ATTR), 10);
-      if (Number.isFinite(id)) state.mountedIds.delete(id);
-      try { state.io?.unobserve(wrap.querySelector(`[id^="${PLACEHOLDER_PREFIX}"]`)); } catch (_) {}
-      wrap.remove();
+      const id = parseInt(w.getAttribute(A_WRAPID), 10);
+      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 (BUG FIX #1) ───────────────────────────────────────────────────
+  // ── Prune ──────────────────────────────────────────────────────────────────
+
   /**
-   * Supprime les wraps dont l'ancre DOM n'est plus connectée.
+   * Supprime les wraps dont l'élément-ancre n'est plus dans le DOM.
    *
-   * Règle simple et sans exception "filled" :
-   *   - Si l'élément ancre est présent et connecté → wrap OK, rien à faire.
-   *   - Si l'élément ancre est absent (virtualisé/retiré) → wrap supprimé,
-   *     qu'il soit rempli ou non. Cela libère l'ID pour réutilisation.
+   * 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 touche PAS aux wraps fraîchement créés (< 5s) pour laisser le
-   * temps à NodeBB de finir d'insérer les posts du batch.
+   * On ne prune pas les wraps < MIN_PRUNE_AGE_MS (DOM pas encore stabilisé).
    */
-  function pruneOrphans(kindClass, selector) {
-    const wraps = document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`);
+  function pruneOrphans(klass) {
+    const meta = KIND[klass];
+    if (!meta) return;
 
-    wraps.forEach(wrap => {
-      const created = parseInt(wrap.getAttribute(CREATED_ATTR) || '0', 10);
-      if (now() - created < 5_000) return; // trop récent, on laisse
+    const baseTag = meta.sel.split('[')[0]; // ex: "li", "[component=..." → "" (géré)
 
-      const anchorKey = wrap.getAttribute(ANCHOR_ATTR);
-      if (!anchorKey) { withInternalMutation(() => removeWrap(wrap)); return; }
+    document.querySelectorAll(`.${WRAP_CLASS}.${klass}`).forEach(w => {
+      if (ts() - parseInt(w.getAttribute(A_CREATED) || '0', 10) < MIN_PRUNE_AGE_MS) return;
 
-      // Retrouver l'ordinal depuis la clé
-      const ordStr = anchorKey.split(':').slice(1).join(':');
-      const ord    = parseInt(ordStr, 10);
+      const key = w.getAttribute(A_ANCHOR) ?? '';
+      const sid = key.slice(klass.length + 1); // extrait la partie après "kindClass:"
+      if (!sid) { mutate(() => dropWrap(w)); return; }
 
-      // Chercher l'élément ancre par son ordinal global (data-index)
-      const anchorEl = isNaN(ord)
-        ? null
-        : document.querySelector(`${selector.split('[')[0]}[data-index="${ord}"]`);
-
-      if (!anchorEl || !anchorEl.isConnected) {
-        // Ancre disparue → suppression inconditionnelle
-        withInternalMutation(() => removeWrap(wrap));
-      }
+      const anchorEl = document.querySelector(
+        `${baseTag}[${meta.anchorAttr}="${sid.replace(/"/g, '\\"')}"]`
+      );
+      if (!anchorEl || !anchorEl.isConnected) mutate(() => dropWrap(w));
     });
   }
 
-  // ─── Decluster (BUG FIX #2) ───────────────────────────────────────────────
+  // ── Decluster ──────────────────────────────────────────────────────────────
+
   /**
-   * Supprime les doublons adjacents.
-   * Ne touche JAMAIS un wrap qui vient de recevoir un showAds() (fill async).
+   * 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(kindClass) {
-    const wraps = Array.from(document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`));
-
-    for (const wrap of wraps) {
-      let prev = wrap.previousElementSibling;
-      let steps = 0;
-      while (prev && steps < 3) {
-        if (prev.classList?.contains(WRAP_CLASS)) {
-          const wShown = parseInt(wrap.getAttribute(SHOWN_ATTR) || '0', 10);
-          const pShown = parseInt(prev.getAttribute(SHOWN_ATTR) || '0', 10);
-          const wFilled = isFilledNode(wrap);
-          const pFilled = isFilledNode(prev);
-
-          // Ne jamais toucher un wrap en cours de fill (dans les FILL_GRACE_MS après show)
-          const wInGrace = wShown && (now() - wShown) < FILL_GRACE_MS;
-          const pInGrace = pShown && (now() - pShown) < FILL_GRACE_MS;
-
-          if (wInGrace || pInGrace) break; // les deux en grace → rien
-
-          if (!wFilled && !wInGrace) {
-            withInternalMutation(() => removeWrap(wrap));
-          } else if (!pFilled && !pInGrace) {
-            withInternalMutation(() => removeWrap(prev));
-          }
-          break;
-        }
-        prev = prev.previousElementSibling;
-        steps++;
+  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 (BUG FIX #3) ───────────────────────────────────────────────
+  // ── Injection ──────────────────────────────────────────────────────────────
+
   /**
-   * Calcule les positions cibles basées sur l'ordinal GLOBAL de chaque item.
-   *
-   * interval=3 → pub après les posts dont (globalOrdinal % interval === interval-1)
-   * c.-à-d. après les posts globaux 2, 5, 8, 11… (0-based)
-   *
-   * showFirst=true → aussi après le post global 0.
-   *
-   * Ce calcul est STABLE entre les batches : si les posts 0-19 sont en DOM,
-   * les cibles sont 2, 5, 8, 11, 14, 17. Si les posts 20-39 arrivent,
-   * les cibles deviennent 20 (si 20%3===2? non), 23, 26, 29, 32, 35, 38.
-   * Jamais de recalcul depuis 0.
+   * 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 injectBetween(kindClass, items, interval, showFirst, poolKey, selector) {
-    if (!items.length) return 0;
+  function ordinal(klass, el) {
+    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;
+  }
 
-    const maxIns = MAX_INSERTS_PER_RUN + (isBoosted() ? 2 : 0);
+  function injectBetween(klass, items, interval, showFirst, poolKey) {
+    if (!items.length) return 0;
     let inserted = 0;
 
     for (const el of items) {
-      if (inserted >= maxIns) break;
+      if (inserted >= MAX_INSERTS_PER_RUN) break;
       if (!el?.isConnected) continue;
 
-      const ord = getGlobalOrdinal(el, selector);
-
-      // Est-ce une position cible ?
+      const ord      = ordinal(klass, el);
       const isTarget = (showFirst && ord === 0) || ((ord + 1) % interval === 0);
       if (!isTarget) continue;
 
-      if (hasAdjacentWrap(el)) continue;
+      if (adjacentWrap(el)) continue;
 
-      const anchorKey = `${kindClass}:${ord}`;
-      if (findWrapByAnchor(anchorKey)) continue;
+      const key = makeAnchorKey(klass, el);
+      if (findWrap(key)) continue; // déjà là → pas de pickId inutile
 
       const id = pickId(poolKey);
-      if (!id) break;
+      if (!id) continue; // pool momentanément épuisé, on continue (items suivants ≠ besoin d'id)
 
-      const wrap = insertWrapAfter(el, id, kindClass, anchorKey);
-      if (!wrap) continue;
-
-      observePlaceholder(id);
-      inserted++;
+      const w = insertAfter(el, id, klass, key);
+      if (w) { observePh(id); inserted++; }
     }
-
     return inserted;
   }
 
-  // ─── Preload / Show ───────────────────────────────────────────────────────
-  function getPreloadMargin() {
-    const m = isMobile() ? 'mobile' : 'desktop';
-    return PRELOAD_MARGIN[m + (isBoosted() ? 'Boosted' : '')];
-  }
-
-  function getMaxInflight() {
-    return (isMobile() ? MAX_INFLIGHT_MOBILE : MAX_INFLIGHT_DESKTOP) + (isBoosted() ? 1 : 0);
-  }
-
-  function ensurePreloadObserver() {
-    const margin = getPreloadMargin();
-    if (state.io && state.ioMargin === margin) return state.io;
-
-    state.io?.disconnect();
-    state.io = null;
+  // ── IntersectionObserver & Show ────────────────────────────────────────────
 
+  function getIO() {
+    if (S.io) return S.io;
+    const margin = isMobile() ? IO_MARGIN_MOBILE : IO_MARGIN_DESKTOP;
     try {
-      state.io = new IntersectionObserver(entries => {
-        for (const ent of entries) {
-          if (!ent.isIntersecting) continue;
-          state.io?.unobserve(ent.target);
-          const id = parseInt(ent.target.getAttribute('data-ezoic-id'), 10);
+      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: margin, threshold: 0 });
-      state.ioMargin = margin;
-    } catch (_) { state.io = null; state.ioMargin = null; }
-
-    try {
-      document.querySelectorAll(`[id^="${PLACEHOLDER_PREFIX}"]`).forEach(n => {
-        try { state.io?.observe(n); } catch (_) {}
-      });
-    } catch (_) {}
-
-    return state.io;
+    } catch (_) { S.io = null; }
+    return S.io;
   }
 
-  function observePlaceholder(id) {
-    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-    if (!ph?.isConnected) return;
-    try { state.io?.observe(ph); } catch (_) {}
-
-    try {
-      const r = ph.getBoundingClientRect();
-      const screens = isBoosted() ? 6 : (isMobile() ? 4 : 2.5);
-      if (r.top < window.innerHeight * screens && r.bottom > -window.innerHeight * 2) {
-        enqueueShow(id);
-      }
-    } catch (_) {}
+  function observePh(id) {
+    const ph = document.getElementById(`${PH_PREFIX}${id}`);
+    if (ph?.isConnected) try { getIO()?.observe(ph); } catch (_) {}
   }
 
   function enqueueShow(id) {
     if (!id || isBlocked()) return;
-    const t = now();
-    if (t - (state.lastShowById.get(id) ?? 0) < SHOW_THROTTLE_MS) return;
-
-    if (state.inflight >= getMaxInflight()) {
-      if (!state.pendingSet.has(id)) { state.pending.push(id); state.pendingSet.add(id); }
+    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);
@@ -461,96 +421,73 @@
 
   function drainQueue() {
     if (isBlocked()) return;
-    while (state.inflight < getMaxInflight() && state.pending.length) {
-      const id = state.pending.shift();
-      state.pendingSet.delete(id);
+    while (S.inflight < MAX_INFLIGHT && S.pending.length) {
+      const id = S.pending.shift();
+      S.pendingSet.delete(id);
       startShow(id);
     }
   }
 
   function startShow(id) {
     if (!id || isBlocked()) return;
-    state.inflight++;
+    S.inflight++;
     let done = false;
-
     const release = () => {
       if (done) return;
       done = true;
-      state.inflight = Math.max(0, state.inflight - 1);
+      S.inflight = Math.max(0, S.inflight - 1);
       drainQueue();
     };
-
-    const timeout = setTimeout(release, 6500);
+    const timer = setTimeout(release, 7000);
 
     requestAnimationFrame(() => {
       try {
-        if (isBlocked()) { clearTimeout(timeout); 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 ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-        if (!ph?.isConnected) { clearTimeout(timeout); return release(); }
-        if (isFilledNode(ph)) { clearTimeout(timeout); return release(); }
-
-        const t = now();
-        if (t - (state.lastShowById.get(id) ?? 0) < SHOW_THROTTLE_MS) {
-          clearTimeout(timeout); return release();
-        }
-        state.lastShowById.set(id, t);
+        const t = ts();
+        if (t - (S.lastShow.get(id) ?? 0) < SHOW_THROTTLE_MS) { clearTimeout(timer); return release(); }
+        S.lastShow.set(id, t);
 
-        // Marquer le timestamp du show sur le wrap (pour decluster grace period)
-        try {
-          const wrap = ph.closest?.(`.${WRAP_CLASS}`);
-          if (wrap) wrap.setAttribute(SHOWN_ATTR, String(t));
-        } catch (_) {}
+        // 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 = () => {
           try { ez.showAds(id); } catch (_) {}
           scheduleEmptyCheck(id, t);
-          setTimeout(() => { clearTimeout(timeout); release(); }, 650);
+          setTimeout(() => { clearTimeout(timer); release(); }, 700);
         };
-
-        if (Array.isArray(ez.cmd)) ez.cmd.push(doShow);
-        else doShow();
-      } catch (_) { clearTimeout(timeout); release(); }
+        Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
+      } catch (_) { clearTimeout(timer); release(); }
     });
   }
 
-  /**
-   * Vérifie si le wrap est toujours vide après EMPTY_CHECK_DELAY.
-   * On compare avec le timestamp du show pour éviter de colapser
-   * un wrap qui aurait reçu un nouveau show entre-temps.
-   */
   function scheduleEmptyCheck(id, showTs) {
     setTimeout(() => {
       try {
-        const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-        if (!ph?.isConnected) return;
-        const wrap = ph.closest?.(`.${WRAP_CLASS}`);
-        if (!wrap) return;
-
-        // Si un nouveau show a eu lieu après celui-ci, ne pas colapser
-        const lastShown = parseInt(wrap.getAttribute(SHOWN_ATTR) || '0', 10);
-        if (lastShown > showTs) return;
-
-        if (!isFilledNode(ph)) wrap.classList.add('is-empty');
-        else wrap.classList.remove('is-empty');
+        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_DELAY);
+    }, EMPTY_CHECK_MS);
   }
 
-  // ─── Patch Ezoic showAds ──────────────────────────────────────────────────
+  // ── Patch Ezoic showAds ────────────────────────────────────────────────────
+
   function patchShowAds() {
     const apply = () => {
       try {
         window.ezstandalone = window.ezstandalone || {};
         const ez = window.ezstandalone;
-        if (window.__nodebbEzoicPatched || typeof ez.showAds !== 'function') return;
-
-        window.__nodebbEzoicPatched = 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;
@@ -558,24 +495,22 @@
           for (const v of ids) {
             const id = parseInt(v, 10);
             if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-            const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-            if (!ph?.isConnected) continue;
+            if (!document.getElementById(`${PH_PREFIX}${id}`)?.isConnected) continue;
             seen.add(id);
             try { orig(id); } catch (_) {}
           }
         };
       } catch (_) {}
     };
-
     apply();
-    if (!window.__nodebbEzoicPatched) {
+    if (!window.__nbbEzPatched) {
       window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      window.ezstandalone.cmd.push(apply);
+      (window.ezstandalone.cmd = window.ezstandalone.cmd || []).push(apply);
     }
   }
 
-  // ─── Core run ─────────────────────────────────────────────────────────────
+  // ── Core run ───────────────────────────────────────────────────────────────
+
   async function runCore() {
     if (isBlocked()) return 0;
     patchShowAds();
@@ -585,232 +520,209 @@
     initPools(cfg);
 
     const kind = getKind();
-    let inserted = 0;
+    if (kind === 'other') return 0;
 
-    /**
-     * @param {string} kindClass
-     * @param {() => Element[]} getItems
-     * @param {string} selector - sélecteur CSS de base (pour ordinal fallback)
-     * @param {*} cfgEnable
-     * @param {number} cfgInterval
-     * @param {*} cfgShowFirst
-     * @param {string} poolKey
-     */
-    const run = (kindClass, getItems, selector, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
+    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);
-      const first    = normBool(cfgShowFirst);
-
-      pruneOrphans(kindClass, selector);
-      const n = injectBetween(kindClass, items, interval, first, poolKey, selector);
-      if (n) decluster(kindClass);
+      pruneOrphans(klass);
+      const n = injectBetween(klass, items, interval, normBool(cfgShowFirst), poolKey);
+      if (n) decluster(klass);
       return n;
     };
 
-    if (kind === 'topic') {
-      inserted += run('ezoic-ad-message', getPostContainers, SELECTORS.postItem,
-        cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts');
-    } else if (kind === 'categoryTopics') {
-      inserted += run('ezoic-ad-between', getTopicItems, SELECTORS.topicItem,
-        cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics');
-    } else if (kind === 'categories') {
-      inserted += run('ezoic-ad-categories', getCategoryItems, SELECTORS.categoryItem,
-        cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories');
-    }
-
-    return inserted;
+    if (kind === 'topic') return exec(
+      'ezoic-ad-message', getPosts,
+      cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts'
+    );
+    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 / Burst ────────────────────────────────────────────────────
-  function scheduleRun(delayMs, cb) {
-    if (state.runQueued) return;
-    state.runQueued = true;
+  // ── Scheduler / Burst ──────────────────────────────────────────────────────
 
-    const run = async () => {
-      state.runQueued = false;
-      if (state.pageKey && getPageKey() !== state.pageKey) return;
+  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 (_) {}
-    };
-
-    const doRun = () => requestAnimationFrame(run);
-    if (delayMs > 0) setTimeout(doRun, delayMs);
-    else doRun();
+    });
   }
 
   function requestBurst() {
     if (isBlocked()) return;
-    const t = now();
-    if (t - state.lastBurstReqTs < 100) return;
-    state.lastBurstReqTs = t;
+    const t = ts();
+    if (t - S.lastBurstTs < BURST_COOLDOWN_MS) return;
+    S.lastBurstTs = t;
 
-    const pk = getPageKey();
-    state.pageKey     = pk;
-    state.burstDeadline = t + 1800;
+    const pk = pageKey();
+    S.pageKey      = pk;
+    S.burstDeadline = t + 2000;
 
-    if (state.burstActive) return;
-    state.burstActive = true;
-    state.burstCount  = 0;
+    if (S.burstActive) return;
+    S.burstActive = true;
+    S.burstCount  = 0;
 
     const step = () => {
-      if (getPageKey() !== pk)          { state.burstActive = false; return; }
-      if (isBlocked())                  { state.burstActive = false; return; }
-      if (now() > state.burstDeadline)  { state.burstActive = false; return; }
-      if (state.burstCount >= 8)        { state.burstActive = false; return; }
-
-      state.burstCount++;
-      scheduleRun(0, (n) => {
-        if (!n && !state.pending.length) { state.burstActive = false; return; }
-        setTimeout(step, n > 0 ? 120 : 250);
+      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 ? 150 : 300);
       });
     };
-
     step();
   }
 
-  // ─── Cleanup ──────────────────────────────────────────────────────────────
-  function cleanup() {
-    blockedUntil = now() + 1500;
+  // ── Cleanup (navigation ajaxify) ───────────────────────────────────────────
 
-    withInternalMutation(() => {
-      document.querySelectorAll(`.${WRAP_CLASS}`).forEach(removeWrap);
-    });
+  function cleanup() {
+    blockedUntil = ts() + 1500;
+    mutate(() => document.querySelectorAll(`.${WRAP_CLASS}`).forEach(dropWrap));
+    S.cfg          = null;
+    S.pools        = { topics: [], posts: [], categories: [] };
+    S.cursors      = { topics: 0, posts: 0, categories: 0 };
+    S.mountedIds.clear();
+    S.lastShow.clear();
+    S.inflight     = 0;
+    S.pending      = [];
+    S.pendingSet.clear();
+    S.burstActive  = false;
+    S.runQueued    = false;
+  }
+
+  // ── DOM Observer ───────────────────────────────────────────────────────────
 
-    state.cfg     = null;
-    state.pools   = { topics: [], posts: [], categories: [] };
-    state.cursors = { topics: 0, posts: 0, categories: 0 };
-    state.mountedIds.clear();
-    state.lastShowById.clear();
-    state.inflight  = 0;
-    state.pending   = [];
-    state.pendingSet.clear();
-    state.burstActive = false;
-    state.runQueued   = false;
-  }
-
-  // ─── DOM Observer ─────────────────────────────────────────────────────────
-  function shouldReact(mutations) {
-    for (const m of mutations) {
-      if (!m.addedNodes?.length) continue;
-      for (const n of m.addedNodes) {
-        if (n.nodeType !== 1) continue;
-        if (n.matches?.(SELECTORS.postItem)     || n.querySelector?.(SELECTORS.postItem)     ||
-            n.matches?.(SELECTORS.topicItem)    || n.querySelector?.(SELECTORS.topicItem)    ||
-            n.matches?.(SELECTORS.categoryItem) || n.querySelector?.(SELECTORS.categoryItem))
-          return true;
+  function ensureDomObserver() {
+    if (S.domObs) return;
+    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 (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;
+          }
+        }
       }
-    }
-    return false;
+    });
+    try { S.domObs.observe(document.body, { childList: true, subtree: true }); } catch (_) {}
   }
 
-  function ensureDomObserver() {
-    if (state.domObs) return;
-    state.domObs = new MutationObserver(mutations => {
-      if (state.internalMutation > 0) return;
-      if (isBlocked()) return;
-      if (!shouldReact(mutations)) return;
-      requestBurst();
-    });
-    try { state.domObs.observe(document.body, { childList: true, subtree: true }); } catch (_) {}
-  }
-
-  // ─── Utilities ────────────────────────────────────────────────────────────
-  function muteNoisyConsole() {
-    if (window.__nodebbEzoicConsoleMuted) return;
-    window.__nodebbEzoicConsoleMuted = true;
-    const MUTED = [
-      '[EzoicAds JS]: Placeholder Id',
-      'Debugger iframe already exists',
-      'HTML element with id ezoic-pub-ad-placeholder-',
-    ];
-    ['log', 'info', 'warn', 'error'].forEach(m => {
+  // ── Utilitaires ────────────────────────────────────────────────────────────
+
+  function muteConsole() {
+    if (window.__nbbEzMuted) return;
+    window.__nbbEzMuted = true;
+    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') return;
-      console[m] = function (...args) {
-        const s = typeof args[0] === 'string' ? args[0] : '';
-        if (MUTED.some(p => s.includes(p))) return;
-        orig.apply(console, args);
+      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() {
+    // 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;
-      if (document.getElementById('__tcfapiLocator')) return;
-      const f = document.createElement('iframe');
-      f.style.display = 'none'; f.id = '__tcfapiLocator'; f.name = '__tcfapiLocator';
-      (document.body || document.documentElement).appendChild(f);
+
+      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 });
+      }
     } catch (_) {}
   }
 
-  const _warmedLinks = new Set();
+  const _warmed = new Set();
   function warmNetwork() {
     const head = document.head;
     if (!head) return;
-    const links = [
+    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 links) {
-      const key = `${rel}|${href}`;
-      if (_warmedLinks.has(key)) continue;
-      _warmedLinks.add(key);
-      const link = document.createElement('link');
-      link.rel = rel; link.href = href;
-      if (cors) link.crossOrigin = 'anonymous';
-      head.appendChild(link);
+    ]) {
+      const k = `${rel}|${href}`;
+      if (_warmed.has(k)) continue;
+      _warmed.add(k);
+      const l = document.createElement('link');
+      l.rel = rel; l.href = href;
+      if (cors) l.crossOrigin = 'anonymous';
+      head.appendChild(l);
     }
   }
 
-  // ─── NodeBB + Scroll bindings ─────────────────────────────────────────────
+  // ── Bindings NodeBB ────────────────────────────────────────────────────────
+
   function bindNodeBB() {
     const $ = window.jQuery;
     if (!$) return;
 
-    $(window).off('.ezoicInfinite');
-
-    $(window).on('action:ajaxify.start.ezoicInfinite', cleanup);
-
-    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
-      state.pageKey = getPageKey();
-      blockedUntil  = 0;
-      muteNoisyConsole();
-      ensureTcfLocator();
-      warmNetwork();
-      patchShowAds();
-      ensurePreloadObserver();
-      ensureDomObserver();
-      requestBurst();
+    $(window).off('.nbbEzoic');
+    $(window).on('action:ajaxify.start.nbbEzoic', cleanup);
+    $(window).on('action:ajaxify.end.nbbEzoic', () => {
+      S.pageKey    = pageKey();
+      blockedUntil = 0;
+      muteConsole(); ensureTcfLocator(); warmNetwork(); patchShowAds();
+      getIO(); ensureDomObserver(); requestBurst();
     });
 
-    const burstEvents = [
+    const BURST_EVENTS = [
       'action:ajaxify.contentLoaded',
-      'action:posts.loaded',
-      'action:topics.loaded',
-      'action:categories.loaded',
-      'action:category.loaded',
-      'action:topic.loaded',
-    ].map(e => `${e}.ezoicInfinite`).join(' ');
+      'action:posts.loaded', 'action:topics.loaded',
+      'action:categories.loaded', 'action:category.loaded', 'action:topic.loaded',
+    ].map(e => `${e}.nbbEzoic`).join(' ');
 
-    $(window).on(burstEvents, () => { 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;
-        [
-          'action:ajaxify.end', 'action:ajaxify.contentLoaded',
-          'action:posts.loaded', 'action:topics.loaded',
-          'action:categories.loaded', 'action:category.loaded', 'action:topic.loaded',
-        ].forEach(ev => {
+        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 (_) {}
   }
@@ -818,35 +730,24 @@
   function bindScroll() {
     let ticking = false;
     window.addEventListener('scroll', () => {
-      try {
-        const t = now(), y = window.scrollY || window.pageYOffset || 0;
-        if (state.lastScrollTs) {
-          const speed = Math.abs(y - state.lastScrollY) / Math.max(1, t - state.lastScrollTs);
-          if (speed >= BOOST_SPEED_PX_PER_MS) {
-            const was = isBoosted();
-            state.scrollBoostUntil = Math.max(state.scrollBoostUntil, t + BOOST_DURATION_MS);
-            if (!was) ensurePreloadObserver();
-          }
-        }
-        state.lastScrollY = y; state.lastScrollTs = t;
-      } catch (_) {}
-
       if (ticking) return;
       ticking = true;
       requestAnimationFrame(() => { ticking = false; requestBurst(); });
     }, { passive: true });
   }
 
-  // ─── Boot ─────────────────────────────────────────────────────────────────
-  state.pageKey = getPageKey();
-  muteNoisyConsole();
+  // ── Boot ───────────────────────────────────────────────────────────────────
+
+  S.pageKey = pageKey();
+  muteConsole();
   ensureTcfLocator();
   warmNetwork();
   patchShowAds();
-  ensurePreloadObserver();
+  getIO();
   ensureDomObserver();
   bindNodeBB();
   bindScroll();
   blockedUntil = 0;
   requestBurst();
+
 })();