nodebb-plugin-ezoic-infinite 1.6.99 → 1.7.0

package/package.json

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

package/public/client.js

@@ -1,46 +1,58 @@
 /**
- * NodeBB Ezoic Infinite Ads — client.js (v18)
+ * NodeBB Ezoic Infinite Ads — client.js (v19)
  *
- * 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 v19 vs v18 :
+ *
+ *  [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 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 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.
  */
 (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';
+  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
 
   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;
+  // 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',
+    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 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"]',
@@ -49,62 +61,47 @@
   };
 
   // ─── Helpers ──────────────────────────────────────────────────────────────
-  const now = () => Date.now();
+  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]'));
 
   function uniqInts(raw) {
     const out = [], seen = new Set();
-    for (const v of String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean)) {
+    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;
   }
 
-  function isFilledNode(node) {
-    return !!(node?.querySelector?.('iframe, ins, img, video, [data-google-container-id]'));
-  }
-
   // ─── State ────────────────────────────────────────────────────────────────
   const state = {
     pageKey: null,
     cfg: null,
 
-    // ID pools + curseurs rotatifs
-    pools: { topics: [], posts: [], categories: [] },
-    cursors: { topics: 0, posts: 0, categories: 0 },
+    pools:   { topics: [], posts: [], categories: [] },
+    cursors: { topics: 0,  posts: 0,  categories: 0  },
 
-    // Suivi des IDs Ezoic actuellement montés dans le DOM (évite les doublons)
+    // IDs Ezoic actuellement montés dans le DOM (Set<number>)
     mountedIds: new Set(),
 
-    // Throttle par id
     lastShowById: new Map(),
 
-    // Observers
     domObs: null,
-    io: null,
-    ioMargin: null,
+    io: null, ioMargin: null,
 
-    // Guard contre nos propres mutations
     internalMutation: 0,
 
-    // File de show
     inflight: 0,
-    pending: [],
-    pendingSet: new Set(),
+    pending: [], pendingSet: new Set(),
 
-    // Scroll boost
     scrollBoostUntil: 0,
-    lastScrollY: 0,
-    lastScrollTs: 0,
+    lastScrollY: 0, lastScrollTs: 0,
 
-    // Scheduler
     runQueued: false,
-    burstActive: false,
-    burstDeadline: 0,
-    burstCount: 0,
-    lastBurstReqTs: 0,
+    burstActive: false, burstDeadline: 0,
+    burstCount: 0, lastBurstReqTs: 0,
   };
 
   let blockedUntil = 0;
@@ -129,10 +126,10 @@
 
   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).
+    // 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);
   }
 
   // ─── Page / Kind ──────────────────────────────────────────────────────────
@@ -147,9 +144,9 @@
 
   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 (/^\/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';
@@ -161,60 +158,84 @@
     return Array.from(document.querySelectorAll(SELECTORS.postItem)).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;
+      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;
     });
   }
 
-  function getTopicItems()    { return Array.from(document.querySelectorAll(SELECTORS.topicItem)); }
+  function getTopicItems()    { return Array.from(document.querySelectorAll(SELECTORS.topicItem));    }
   function getCategoryItems() { return Array.from(document.querySelectorAll(SELECTORS.categoryItem)); }
 
+  function hasAdjacentWrap(el) {
+    return !!(el.nextElementSibling?.classList?.contains(WRAP_CLASS) ||
+              el.previousElementSibling?.classList?.contains(WRAP_CLASS));
+  }
+
+  // ─── Ordinal global (BUG FIX #3) ──────────────────────────────────────────
   /**
-   * 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'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.
    */
-  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 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
 
-  function findWrapByAnchor(anchorKey) {
-    return document.querySelector(`.${WRAP_CLASS}[${ANCHOR_ATTR}="${CSS.escape(anchorKey)}"]`);
-  }
+    // 2. Compter dans le DOM parmi les frères du même type
+    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++;
+        }
+      }
+    } catch (_) {}
 
-  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;
+    return 0;
   }
 
-  // ─── ID pool / rotation ───────────────────────────────────────────────────
   /**
-   * Retourne le prochain id disponible du pool (non déjà monté dans le DOM),
-   * en avançant le curseur rotatif.
+   * 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}`;
+  }
+
+  function findWrapByAnchor(anchorKey) {
+    // CSS.escape pour les : dans la clé
+    try {
+      return document.querySelector(`.${WRAP_CLASS}[${ANCHOR_ATTR}="${anchorKey.replace(/"/g, '\\"')}"]`);
+    } catch (_) { return null; }
+  }
+
+  // ─── Pool rotation ────────────────────────────────────────────────────────
   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;
+    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;
     }
-    return null; // Tous les IDs déjà montés
+    return null;
   }
 
-  // ─── Wrap construction ────────────────────────────────────────────────────
+  // ─── Wrap build / insert / remove ─────────────────────────────────────────
   function buildWrap(id, kindClass, anchorKey) {
     const wrap = document.createElement('div');
     wrap.className = `${WRAP_CLASS} ${kindClass}`;
@@ -227,20 +248,14 @@
     ph.id = `${PLACEHOLDER_PREFIX}${id}`;
     ph.setAttribute('data-ezoic-id', String(id));
     wrap.appendChild(ph);
-
     return wrap;
   }
 
   function insertWrapAfter(el, id, kindClass, anchorKey) {
     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;
-    }
+    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));
@@ -252,119 +267,123 @@
     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();
     } catch (_) {}
   }
 
-  // ─── Prune & Decluster ────────────────────────────────────────────────────
+  // ─── Prune (BUG FIX #1) ───────────────────────────────────────────────────
   /**
-   * 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.
+   * Supprime les wraps dont l'ancre DOM n'est plus connectée.
+   *
+   * 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.
+   *
+   * 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.
    */
-  function pruneOrphans(kindClass) {
+  function pruneOrphans(kindClass, selector) {
     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;
+      if (now() - created < 5_000) return; // trop récent, on laisse
 
       const anchorKey = wrap.getAttribute(ANCHOR_ATTR);
-      if (!anchorKey) {
-        withInternalMutation(() => removeWrap(wrap));
-        removed++;
-        return;
-      }
+      if (!anchorKey) { withInternalMutation(() => removeWrap(wrap)); return; }
 
-      // L'ancre existe-t-elle encore dans le DOM ?
-      const [, anchorId] = anchorKey.split(':');
-      const isPost = kindClass === 'ezoic-ad-message';
-      let anchorEl = null;
+      // Retrouver l'ordinal depuis la clé
+      const ordStr = anchorKey.split(':').slice(1).join(':');
+      const ord    = parseInt(ordStr, 10);
 
-      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)}"]`);
-      }
+      // 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 → si rempli on garde (scrolling back), si vide on supprime
-        if (!isFilledNode(wrap)) {
-          withInternalMutation(() => removeWrap(wrap));
-          removed++;
-        }
+        // Ancre disparue → suppression inconditionnelle
+        withInternalMutation(() => removeWrap(wrap));
       }
     });
-
-    return removed;
   }
 
+  // ─── Decluster (BUG FIX #2) ───────────────────────────────────────────────
   /**
-   * Si deux wraps se retrouvent consécutifs (sans item entre eux),
-   * on supprime le plus récent des deux s'il est vide.
+   * Supprime les doublons adjacents.
+   * Ne touche JAMAIS un wrap qui vient de recevoir un showAds() (fill async).
    */
   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);
+          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) {
+          if (!wFilled && !wInGrace) {
             withInternalMutation(() => removeWrap(wrap));
-            removed++;
-          } else if (!pFilled) {
+          } else if (!pFilled && !pInGrace) {
             withInternalMutation(() => removeWrap(prev));
-            removed++;
           }
-          // Si les deux sont remplis, laisser en place
           break;
         }
         prev = prev.previousElementSibling;
         steps++;
       }
     }
-
-    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);
   }
 
-  function injectBetween(kindClass, items, interval, showFirst, poolKey) {
+  // ─── Injection (BUG FIX #3) ───────────────────────────────────────────────
+  /**
+   * 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.
+   */
+  function injectBetween(kindClass, items, interval, showFirst, poolKey, selector) {
     if (!items.length) return 0;
 
-    const targets  = computeTargetIndices(items.length, interval, showFirst);
-    const maxIns   = MAX_INSERTS_PER_RUN + (isBoosted() ? 2 : 0);
-    let inserted   = 0;
+    const maxIns = MAX_INSERTS_PER_RUN + (isBoosted() ? 2 : 0);
+    let inserted = 0;
 
-    for (const idx of targets) {
+    for (const el of items) {
       if (inserted >= maxIns) break;
-
-      const el         = items[idx];
       if (!el?.isConnected) continue;
+
+      const ord = getGlobalOrdinal(el, selector);
+
+      // Est-ce une position cible ?
+      const isTarget = (showFirst && ord === 0) || ((ord + 1) % interval === 0);
+      if (!isTarget) continue;
+
       if (hasAdjacentWrap(el)) continue;
 
-      const anchorKey  = getAnchorKey(kindClass, el, idx);
-      if (findWrapByAnchor(anchorKey)) continue; // déjà là
+      const anchorKey = `${kindClass}:${ord}`;
+      if (findWrapByAnchor(anchorKey)) continue;
 
       const id = pickId(poolKey);
-      if (!id) break; // pool épuisé pour cette passe
+      if (!id) break;
 
       const wrap = insertWrapAfter(el, id, kindClass, anchorKey);
       if (!wrap) continue;
@@ -405,7 +424,6 @@
       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 (_) {}
@@ -420,7 +438,6 @@
     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);
@@ -436,10 +453,7 @@
     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 (!state.pendingSet.has(id)) { state.pending.push(id); state.pendingSet.add(id); }
       return;
     }
     startShow(id);
@@ -470,45 +484,60 @@
 
     requestAnimationFrame(() => {
       try {
-        if (isBlocked()) return release();
+        if (isBlocked()) { clearTimeout(timeout); return release(); }
+
         const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-        if (!ph?.isConnected) return release();
+        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) return release();
+        if (t - (state.lastShowById.get(id) ?? 0) < SHOW_THROTTLE_MS) {
+          clearTimeout(timeout); return release();
+        }
         state.lastShowById.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 (_) {}
+
         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(timeout); release(); }, 650);
         };
 
         if (Array.isArray(ez.cmd)) ez.cmd.push(doShow);
         else doShow();
-      } finally { /* timeout covers us */ }
+      } catch (_) { clearTimeout(timeout); release(); }
     });
   }
 
-  function scheduleEmptyCheck(id) {
+  /**
+   * 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}`);
+        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;
+        // 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');
       } catch (_) {}
-    }, 15_000);
+    }, EMPTY_CHECK_DELAY);
   }
 
   // ─── Patch Ezoic showAds ──────────────────────────────────────────────────
@@ -558,23 +587,35 @@
     const kind = getKind();
     let inserted = 0;
 
-    const run = (kindClass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
+    /**
+     * @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) => {
       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);
+      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);
       return n;
     };
 
     if (kind === 'topic') {
-      inserted += run('ezoic-ad-message', getPostContainers,
+      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,
+      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,
+      inserted += run('ezoic-ad-categories', getCategoryItems, SELECTORS.categoryItem,
         cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories');
     }
 
@@ -582,7 +623,7 @@
   }
 
   // ─── Scheduler / Burst ────────────────────────────────────────────────────
-  function scheduleRun(delayMs = 0, cb) {
+  function scheduleRun(delayMs, cb) {
     if (state.runQueued) return;
     state.runQueued = true;
 
@@ -606,7 +647,7 @@
     state.lastBurstReqTs = t;
 
     const pk = getPageKey();
-    state.pageKey = pk;
+    state.pageKey     = pk;
     state.burstDeadline = t + 1800;
 
     if (state.burstActive) return;
@@ -614,10 +655,10 @@
     state.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; }
+      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) => {
@@ -629,26 +670,22 @@
     step();
   }
 
-  // ─── Cleanup (ajaxify navigation) ─────────────────────────────────────────
+  // ─── Cleanup ──────────────────────────────────────────────────────────────
   function cleanup() {
-    // Bloquer toute injection pendant la transition
     blockedUntil = now() + 1500;
 
-    // Supprimer tous les wraps injectés → libère les IDs
     withInternalMutation(() => {
       document.querySelectorAll(`.${WRAP_CLASS}`).forEach(removeWrap);
     });
 
-    // Réinitialiser l'état complet
-    state.cfg         = null;
-    state.pools       = { topics: [], posts: [], categories: [] };
-    state.cursors     = { topics: 0, posts: 0, categories: 0 };
+    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.inflight  = 0;
+    state.pending   = [];
     state.pendingSet.clear();
-
     state.burstActive = false;
     state.runQueued   = false;
   }
@@ -659,11 +696,10 @@
       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;
+        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;
       }
     }
     return false;
@@ -680,7 +716,7 @@
     try { state.domObs.observe(document.body, { childList: true, subtree: true }); } catch (_) {}
   }
 
-  // ─── Utilities: console mute + TCF + network warm ─────────────────────────
+  // ─── Utilities ────────────────────────────────────────────────────────────
   function muteNoisyConsole() {
     if (window.__nodebbEzoicConsoleMuted) return;
     window.__nodebbEzoicConsoleMuted = true;
@@ -704,9 +740,8 @@
     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 = '__tcfapiLocator'; f.name = '__tcfapiLocator';
       (document.body || document.documentElement).appendChild(f);
     } catch (_) {}
   }
@@ -716,12 +751,12 @@
     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],
+      ['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}`;
@@ -741,9 +776,7 @@
 
     $(window).off('.ezoicInfinite');
 
-    $(window).on('action:ajaxify.start.ezoicInfinite', () => {
-      cleanup();
-    });
+    $(window).on('action:ajaxify.start.ezoicInfinite', cleanup);
 
     $(window).on('action:ajaxify.end.ezoicInfinite', () => {
       state.pageKey = getPageKey();
@@ -768,7 +801,6 @@
 
     $(window).on(burstEvents, () => { if (!isBlocked()) requestBurst(); });
 
-    // Hooks AMD (NodeBB 4.x)
     try {
       require(['hooks'], hooks => {
         if (typeof hooks?.on !== 'function') return;
@@ -786,20 +818,17 @@
   function bindScroll() {
     let ticking = false;
     window.addEventListener('scroll', () => {
-      // Scroll boost
       try {
-        const t  = now();
-        const y  = window.scrollY || window.pageYOffset || 0;
+        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 wasBoosted = isBoosted();
+            const was = isBoosted();
             state.scrollBoostUntil = Math.max(state.scrollBoostUntil, t + BOOST_DURATION_MS);
-            if (!wasBoosted) ensurePreloadObserver();
+            if (!was) ensurePreloadObserver();
           }
         }
-        state.lastScrollY  = y;
-        state.lastScrollTs = t;
+        state.lastScrollY = y; state.lastScrollTs = t;
       } catch (_) {}
 
       if (ticking) return;