nodebb-plugin-ezoic-infinite 1.6.99 → 1.7.1

package/public/client.js

@@ -1,445 +1,413 @@
 /**
- * NodeBB Ezoic Infinite Ads — client.js (v18)
+ * NodeBB Ezoic Infinite Ads — client.js (v20)
  *
- * Corrections majeures vs v17 :
- *  1. ANCRAGE PAR pid/tid (data-pid, data-index) au lieu d'ordinalMap fragile.
- *     → Le même post garde toujours le même ID de wrap, quelle que soit la virtualisation.
- *  2. CLEANUP COMPLET à chaque navigation ajaxify (wraps + curseurs + état pools).
- *     → Supprime les fantômes qui se réaffichaient après scroll up/down.
- *  3. DEDUPLICATION par ancrage : on vérifie `data-ezoic-anchor` avant d'insérer.
- *     → Empêche la création de doublons lors de multiples passes DOM.
- *  4. PAS de recyclage de wraps (moveWrapAfter supprimé).
- *     → La cause n°1 des pubs "qui sautent n'importe où".
- *  5. pruneOrphanWraps simplifié : suppression réelle (remove) au lieu de hide.
- *     → Un wrap orphelin = mort, pas caché. Libère l'id dans le curseur.
- *  6. Déduplication de l'id Ezoic par wrap : un id ne peut être monté qu'une fois.
- *  7. V17 pile-fix SUPPRIMÉ (was conflicting with main logic).
- *  8. Factorisation : helpers partagés, pas de duplication de logique entre kinds.
+ * 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';
 
-  // ─── Constants ────────────────────────────────────────────────────────────
-  const WRAP_CLASS          = 'nodebb-ezoic-wrap';
-  const PLACEHOLDER_PREFIX  = 'ezoic-pub-ad-placeholder-';
-  const ANCHOR_ATTR         = 'data-ezoic-anchor'; // unique key = kind:anchorId
-  const WRAPID_ATTR         = 'data-ezoic-wrapid';
-  const CREATED_ATTR        = 'data-ezoic-created';
+  // ── 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;
-  const EMPTY_WRAP_TTL_MS   = 90_000; // 90 s avant de colapser un wrap vide
-  const FILL_WATCH_MS       = 7_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';
-
-  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;
-  }
+  /**
+   * 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 isFilledNode(node) {
-    return !!(node?.querySelector?.('iframe, ins, img, video, [data-google-container-id]'));
-  }
+  // ── État ───────────────────────────────────────────────────────────────────
 
-  // ─── State ────────────────────────────────────────────────────────────────
-  const state = {
+  const S = {
     pageKey: null,
     cfg: null,
 
-    // ID pools + curseurs rotatifs
-    pools: { topics: [], posts: [], categories: [] },
-    cursors: { topics: 0, posts: 0, categories: 0 },
-
-    // Suivi des IDs Ezoic actuellement montés dans le DOM (évite les doublons)
-    mountedIds: new Set(),
-
-    // Throttle par id
-    lastShowById: new Map(),
-
-    // Observers
-    domObs: null,
-    io: null,
-    ioMargin: null,
-
-    // Guard contre nos propres mutations
-    internalMutation: 0,
+    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
 
-    // File de show
-    inflight: 0,
-    pending: [],
-    pendingSet: new Set(),
+    io:      null,
+    domObs:  null,
+    mutGuard: 0,                // compteur internalMutation
 
-    // Scroll boost
-    scrollBoostUntil: 0,
-    lastScrollY: 0,
-    lastScrollTs: 0,
+    inflight:    0,
+    pending:     [],
+    pendingSet:  new Set(),
 
-    // Scheduler
-    runQueued: false,
-    burstActive: false,
+    runQueued:    false,
+    burstActive:  false,
     burstDeadline: 0,
-    burstCount: 0,
-    lastBurstReqTs: 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;
-    state.pools.topics     = uniqInts(cfg.placeholderIds || '');
-    state.pools.posts      = uniqInts(cfg.messagePlaceholderIds || '');
-    state.pools.categories = uniqInts(cfg.categoryPlaceholderIds || '');
-    // Ne pas réinitialiser les curseurs ici (ils sont remis à 0 dans cleanup).
+    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)) {
+      const n = parseInt(v, 10);
+      if (n > 0 && Number.isFinite(n) && !seen.has(n)) { seen.add(n); out.push(n); }
+    }
+    return out;
   }
 
-  // ─── Page / Kind ──────────────────────────────────────────────────────────
-  function getPageKey() {
+  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 (/^\/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 (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 parentPost = el.parentElement?.closest('[component="post"][data-pid]');
-      if (parentPost && parentPost !== 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 adjacentWrap(el) {
+    return !!(
+      el.nextElementSibling?.classList?.contains(WRAP_CLASS) ||
+      el.previousElementSibling?.classList?.contains(WRAP_CLASS)
+    );
+  }
+
+  // ── Ancres stables ────────────────────────────────────────────────────────
 
   /**
-   * Calcule l'ancre stable d'un élément : on préfère data-pid (posts) puis
-   * data-index, sinon on retombe sur l'index dans le tableau.
-   * La clé est préfixée par kindClass pour éviter les collisions.
+   * 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 getAnchorKey(kindClass, el, fallbackIndex) {
-    const pid   = el.getAttribute('data-pid');
-    const index = el.getAttribute('data-index') ?? el.getAttribute('data-idx');
-    const id    = pid ?? index ?? String(fallbackIndex);
-    return `${kindClass}:${id}`;
+  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 {
+      let i = 0;
+      for (const s of el.parentElement?.children ?? []) {
+        if (s === el) return `i${i}`;
+        i++;
+      }
+    } catch (_) {}
+    return 'i0';
   }
 
-  function findWrapByAnchor(anchorKey) {
-    return document.querySelector(`.${WRAP_CLASS}[${ANCHOR_ATTR}="${CSS.escape(anchorKey)}"]`);
-  }
+  const makeAnchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
 
-  function hasAdjacentWrap(el) {
-    const next = el.nextElementSibling;
-    if (next?.classList?.contains(WRAP_CLASS)) return true;
-    const prev = el.previousElementSibling;
-    if (prev?.classList?.contains(WRAP_CLASS)) return true;
-    return false;
+  function findWrap(anchorKey) {
+    try {
+      return document.querySelector(
+        `.${WRAP_CLASS}[${A_ANCHOR}="${anchorKey.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"]`
+      );
+    } catch (_) { return null; }
   }
 
-  // ─── ID pool / rotation ───────────────────────────────────────────────────
-  /**
-   * Retourne le prochain id disponible du pool (non déjà monté dans le DOM),
-   * en avançant le curseur rotatif.
-   */
+  // ── Pool ───────────────────────────────────────────────────────────────────
+
   function pickId(poolKey) {
-    const pool = state.pools[poolKey];
-    const n    = pool.length;
-    if (!n) return null;
-
-    for (let tries = 0; tries < n; tries++) {
-      const idx = state.cursors[poolKey] % n;
-      state.cursors[poolKey] = (state.cursors[poolKey] + 1) % n;
-      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; // Tous les IDs déjà montés
+    return null;
   }
 
-  // ─── Wrap construction ────────────────────────────────────────────────────
-  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à présent
-    if (state.mountedIds.has(id))     return null; // id déjà monté
-
-    const existingPh = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-    if (existingPh?.isConnected) {
-      // Cet id a déjà un placeholder dans le DOM → on ne peut pas le dupliquer
-      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);
-      wrap.remove();
+      const id = parseInt(w.getAttribute(A_WRAPID), 10);
+      if (Number.isFinite(id)) S.mountedIds.delete(id);
+      try { S.io?.unobserve(w.querySelector(`[id^="${PH_PREFIX}"]`)); } catch (_) {}
+      w.remove();
     } catch (_) {}
   }
 
-  // ─── Prune & Decluster ────────────────────────────────────────────────────
+  // ── Prune ──────────────────────────────────────────────────────────────────
+
   /**
    * Supprime les wraps dont l'élément-ancre n'est plus dans le DOM.
-   * On supprime proprement (remove) plutôt que de cacher → libère l'id.
+   *
+   * 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(kindClass) {
-    const wraps = document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`);
-    let removed = 0;
-
-    wraps.forEach(wrap => {
-      // Ne jamais pruner un wrap tout juste créé (fill lent côté Ezoic)
-      const created = parseInt(wrap.getAttribute(CREATED_ATTR) || '0', 10);
-      if (created && (now() - created) < EMPTY_WRAP_TTL_MS) return;
-
-      const anchorKey = wrap.getAttribute(ANCHOR_ATTR);
-      if (!anchorKey) {
-        withInternalMutation(() => removeWrap(wrap));
-        removed++;
-        return;
-      }
+  function pruneOrphans(klass) {
+    const meta = KIND[klass];
+    if (!meta) return;
 
-      // L'ancre existe-t-elle encore dans le DOM ?
-      const [, anchorId] = anchorKey.split(':');
-      const isPost = kindClass === 'ezoic-ad-message';
-      let anchorEl = null;
+    const baseTag = meta.sel.split('[')[0]; // ex: "li", "[component=..." → "" (géré)
 
-      if (isPost) {
-        anchorEl = document.querySelector(`[component="post"][data-pid="${CSS.escape(anchorId)}"]`);
-      } else {
-        anchorEl = document.querySelector(`${SELECTORS.topicItem}[data-index="${CSS.escape(anchorId)}"]`)
-                ?? document.querySelector(`${SELECTORS.categoryItem}[data-index="${CSS.escape(anchorId)}"]`);
-      }
+    document.querySelectorAll(`.${WRAP_CLASS}.${klass}`).forEach(w => {
+      if (ts() - parseInt(w.getAttribute(A_CREATED) || '0', 10) < MIN_PRUNE_AGE_MS) return;
 
-      if (!anchorEl || !anchorEl.isConnected) {
-        // Ancre disparue → si rempli on garde (scrolling back), si vide on supprime
-        if (!isFilledNode(wrap)) {
-          withInternalMutation(() => removeWrap(wrap));
-          removed++;
-        }
-      }
-    });
+      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; }
 
-    return removed;
+      const anchorEl = document.querySelector(
+        `${baseTag}[${meta.anchorAttr}="${sid.replace(/"/g, '\\"')}"]`
+      );
+      if (!anchorEl || !anchorEl.isConnected) mutate(() => dropWrap(w));
+    });
   }
 
+  // ── Decluster ──────────────────────────────────────────────────────────────
+
   /**
-   * Si deux wraps se retrouvent consécutifs (sans item entre eux),
-   * on supprime le plus récent des deux s'il est vide.
+   * 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}`));
-    let removed = 0;
-
-    for (const wrap of wraps) {
-      let prev = wrap.previousElementSibling;
-      let steps = 0;
-      while (prev && steps < 3) {
-        if (prev.classList?.contains(WRAP_CLASS)) {
-          // Deux wraps consécutifs : supprimer le plus vide/récent
-          const wCreated  = parseInt(wrap.getAttribute(CREATED_ATTR) || '0', 10);
-          const pCreated  = parseInt(prev.getAttribute(CREATED_ATTR) || '0', 10);
-          const wFilled   = isFilledNode(wrap);
-          const pFilled   = isFilledNode(prev);
-
-          if (!wFilled) {
-            withInternalMutation(() => removeWrap(wrap));
-            removed++;
-          } else if (!pFilled) {
-            withInternalMutation(() => removeWrap(prev));
-            removed++;
-          }
-          // Si les deux sont remplis, laisser en place
-          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;
       }
     }
-
-    return removed;
   }
 
-  // ─── Injection ────────────────────────────────────────────────────────────
-  function computeTargetIndices(count, interval, showFirst) {
-    const targets = new Set();
-    if (showFirst && count > 0) targets.add(0);
-    for (let i = interval - 1; i < count; i += interval) targets.add(i);
-    return [...targets].sort((a, b) => a - b);
+  // ── Injection ──────────────────────────────────────────────────────────────
+
+  /**
+   * 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 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;
   }
 
-  function injectBetween(kindClass, items, interval, showFirst, poolKey) {
+  function injectBetween(klass, items, interval, showFirst, poolKey) {
     if (!items.length) return 0;
+    let inserted = 0;
 
-    const targets  = computeTargetIndices(items.length, interval, showFirst);
-    const maxIns   = MAX_INSERTS_PER_RUN + (isBoosted() ? 2 : 0);
-    let inserted   = 0;
+    for (const el of items) {
+      if (inserted >= MAX_INSERTS_PER_RUN) break;
+      if (!el?.isConnected) continue;
 
-    for (const idx of targets) {
-      if (inserted >= maxIns) break;
+      const ord      = ordinal(klass, el);
+      const isTarget = (showFirst && ord === 0) || ((ord + 1) % interval === 0);
+      if (!isTarget) continue;
 
-      const el         = items[idx];
-      if (!el?.isConnected) continue;
-      if (hasAdjacentWrap(el)) continue;
+      if (adjacentWrap(el)) continue;
 
-      const anchorKey  = getAnchorKey(kindClass, el, idx);
-      if (findWrapByAnchor(anchorKey)) continue; // déjà là
+      const key = makeAnchorKey(klass, el);
+      if (findWrap(key)) continue; // déjà là → pas de pickId inutile
 
       const id = pickId(poolKey);
-      if (!id) break; // pool épuisé pour cette passe
+      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;
+          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; }
-
-    // Ré-observer les placeholders déjà dans le DOM
-    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 (_) {}
-
-    // Si déjà proche du viewport → show immédiat
-    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);
@@ -447,81 +415,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()) return release();
-        const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-        if (!ph?.isConnected) return release();
-        if (isFilledNode(ph)) { 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 t = now();
-        if (t - (state.lastShowById.get(id) ?? 0) < SHOW_THROTTLE_MS) 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);
+
+        // 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);
-          setTimeout(release, 650);
+          scheduleEmptyCheck(id, t);
+          setTimeout(() => { clearTimeout(timer); release(); }, 700);
         };
-
-        if (Array.isArray(ez.cmd)) ez.cmd.push(doShow);
-        else doShow();
-      } finally { /* timeout covers us */ }
+        Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
+      } catch (_) { clearTimeout(timer); release(); }
     });
   }
 
-  function scheduleEmptyCheck(id) {
+  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;
-
-        const created = parseInt(wrap.getAttribute(CREATED_ATTR) || '0', 10);
-        if (created && (now() - created) < EMPTY_WRAP_TTL_MS) 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 (_) {}
-    }, 15_000);
+    }, 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;
@@ -529,24 +489,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();
@@ -556,229 +514,191 @@
     initPools(cfg);
 
     const kind = getKind();
-    let inserted = 0;
+    if (kind === 'other') return 0;
 
-    const run = (kindClass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
+    const exec = (klass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
       if (!normBool(cfgEnable)) return 0;
-      const items = getItems();
-      pruneOrphans(kindClass);
-      const n = injectBetween(kindClass, items, Math.max(1, parseInt(cfgInterval, 10) || 3), normBool(cfgShowFirst), poolKey);
-      if (n) decluster(kindClass);
+      const items    = getItems();
+      const interval = Math.max(1, parseInt(cfgInterval, 10) || 3);
+      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,
-        cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts');
-    } else if (kind === 'categoryTopics') {
-      inserted += run('ezoic-ad-between', getTopicItems,
-        cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics');
-    } else if (kind === 'categories') {
-      inserted += run('ezoic-ad-categories', getCategoryItems,
-        cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories');
-    }
-
-    return inserted;
-  }
-
-  // ─── Scheduler / Burst ────────────────────────────────────────────────────
-  function scheduleRun(delayMs = 0, cb) {
-    if (state.runQueued) return;
-    state.runQueued = true;
-
-    const run = async () => {
-      state.runQueued = false;
-      if (state.pageKey && getPageKey() !== state.pageKey) return;
+    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(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 (ajaxify navigation) ─────────────────────────────────────────
-  function cleanup() {
-    // Bloquer toute injection pendant la transition
-    blockedUntil = now() + 1500;
+  // ── Cleanup (navigation ajaxify) ───────────────────────────────────────────
 
-    // Supprimer tous les wraps injectés → libère les IDs
-    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 ───────────────────────────────────────────────────────────
 
-    // Réinitialiser l'état complet
-    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: console mute + TCF + network warm ─────────────────────────
-  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() {
     try {
       if (!window.__tcfapi && !window.__cmp) return;
       if (document.getElementById('__tcfapiLocator')) return;
-      const f = Object.assign(document.createElement('iframe'), {
-        style: 'display:none', id: '__tcfapiLocator', name: '__tcfapiLocator',
-      });
+      const f = document.createElement('iframe');
+      f.style.display = 'none'; f.id = f.name = '__tcfapiLocator';
       (document.body || document.documentElement).appendChild(f);
     } catch (_) {}
   }
 
-  const _warmedLinks = new Set();
+  const _warmed = new Set();
   function warmNetwork() {
     const head = document.head;
     if (!head) return;
-    const links = [
-      ['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);
+    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],
+    ]) {
+      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)
+    // 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 (_) {}
   }
@@ -786,38 +706,24 @@
   function bindScroll() {
     let ticking = false;
     window.addEventListener('scroll', () => {
-      // Scroll boost
-      try {
-        const t  = now();
-        const 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 wasBoosted = isBoosted();
-            state.scrollBoostUntil = Math.max(state.scrollBoostUntil, t + BOOST_DURATION_MS);
-            if (!wasBoosted) 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();
+
 })();