nodebb-plugin-ezoic-infinite 1.8.16 → 1.8.18

package/library.js

@@ -1,16 +1,24 @@
 'use strict';
 
-const meta = require.main.require('./src/meta');
+const meta   = require.main.require('./src/meta');
 const groups = require.main.require('./src/groups');
-const db = require.main.require('./src/database');
+const db     = require.main.require('./src/database');
 
 const SETTINGS_KEY = 'ezoic-infinite';
 const plugin = {};
 
+// ── Helpers ────────────────────────────────────────────────────────────────
+
 function normalizeExcludedGroups(value) {
   if (!value) return [];
   if (Array.isArray(value)) return value;
-  return String(value).split(',').map(s => s.trim()).filter(Boolean);
+  // NodeBB stocke les settings multi-valeurs comme string JSON "[\"group1\",\"group2\"]"
+  const s = String(value).trim();
+  if (s.startsWith('[')) {
+    try { const parsed = JSON.parse(s); if (Array.isArray(parsed)) return parsed.map(String).filter(Boolean); } catch (_) {}
+  }
+  // Fallback : séparation par virgule
+  return s.split(',').map(v => v.trim()).filter(Boolean);
 }
 
 function parseBool(v, def = false) {
@@ -21,33 +29,22 @@ function parseBool(v, def = false) {
 }
 
 async function getAllGroups() {
-  const now = Date.now();
-  if (_groupsCache && (now - _groupsCacheAt) < GROUPS_TTL) return _groupsCache;
-
   let names = await db.getSortedSetRange('groups:createtime', 0, -1);
   if (!names || !names.length) {
     names = await db.getSortedSetRange('groups:visible:createtime', 0, -1);
   }
   const filtered = names.filter(name => !groups.isPrivilegeGroup(name));
   const data = await groups.getGroupsData(filtered);
-  const valid = (data || []).filter(g => g && g.name);
+  const valid = data.filter(g => g && g.name);
   valid.sort((a, b) => String(a.name).localeCompare(String(b.name), undefined, { sensitivity: 'base' }));
-
-  _groupsCacheAt = now;
-  _groupsCache = valid;
   return valid;
 }
 
-let _settingsCache = null;
-let _settingsCacheAt = 0;
-const SETTINGS_TTL = 30000; // 30s
-
-let _groupsCache = null;
-let _groupsCacheAt = 0;
-const GROUPS_TTL = 5 * 60 * 1000; // 5min
+// ── Settings cache (30s TTL) ────────────────────────────────────────────────
 
-const _excludedCache = new Map(); // uid -> { at, excluded }
-const EXCLUDED_TTL = 30 * 1000; // 30s
+let _settingsCache   = null;
+let _settingsCacheAt = 0;
+const SETTINGS_TTL   = 30_000;
 
 async function getSettings() {
   const now = Date.now();
@@ -55,101 +52,146 @@ async function getSettings() {
   const s = await meta.settings.get(SETTINGS_KEY);
   _settingsCacheAt = Date.now();
   _settingsCache = {
-    // Between-post ads (simple blocks) in category topic list
-    enableBetweenAds: parseBool(s.enableBetweenAds, true),
-    showFirstTopicAd: parseBool(s.showFirstTopicAd, false),
-    placeholderIds: (s.placeholderIds || '').trim(),
-    intervalPosts: Math.max(1, parseInt(s.intervalPosts, 10) || 6),
-
-    // Home/categories list ads (between categories on / or /categories)
-    enableCategoryAds: parseBool(s.enableCategoryAds, false),
-    showFirstCategoryAd: parseBool(s.showFirstCategoryAd, false),
+    enableBetweenAds:       parseBool(s.enableBetweenAds, true),
+    showFirstTopicAd:       parseBool(s.showFirstTopicAd, false),
+    placeholderIds:         (s.placeholderIds || '').trim(),
+    intervalPosts:          Math.max(1, parseInt(s.intervalPosts, 10) || 6),
+    enableCategoryAds:      parseBool(s.enableCategoryAds, false),
+    showFirstCategoryAd:    parseBool(s.showFirstCategoryAd, false),
     categoryPlaceholderIds: (s.categoryPlaceholderIds || '').trim(),
-    intervalCategories: Math.max(1, parseInt(s.intervalCategories, 10) || 4),
-
-    // "Ad message" between replies (looks like a post)
-    enableMessageAds: parseBool(s.enableMessageAds, false),
-    showFirstMessageAd: parseBool(s.showFirstMessageAd, false),
-    messagePlaceholderIds: (s.messagePlaceholderIds || '').trim(),
-    messageIntervalPosts: Math.max(1, parseInt(s.messageIntervalPosts, 10) || 3),
-
-    excludedGroups: normalizeExcludedGroups(s.excludedGroups),
+    intervalCategories:     Math.max(1, parseInt(s.intervalCategories, 10) || 4),
+    enableMessageAds:       parseBool(s.enableMessageAds, false),
+    showFirstMessageAd:     parseBool(s.showFirstMessageAd, false),
+    messagePlaceholderIds:  (s.messagePlaceholderIds || '').trim(),
+    messageIntervalPosts:   Math.max(1, parseInt(s.messageIntervalPosts, 10) || 3),
+    excludedGroups:         normalizeExcludedGroups(s.excludedGroups),
   };
   return _settingsCache;
 }
 
 async function isUserExcluded(uid, excludedGroups) {
   if (!uid || !excludedGroups.length) return false;
+  const userGroups = await groups.getUserGroups([uid]);
+  return (userGroups[0] || []).some(g => excludedGroups.includes(g.name));
+}
+
+
+
+// ── Groups cache (5 min TTL) ───────────────────────────────────────────────
+
+let _groupsCache = null;
+let _groupsCacheAt = 0;
+const GROUPS_TTL = 5 * 60_000;
 
+async function getAllGroupsCached() {
   const now = Date.now();
-  const cached = _excludedCache.get(uid);
-  if (cached && (now - cached.at) < EXCLUDED_TTL) return cached.excluded;
+  if (_groupsCache && (now - _groupsCacheAt) < GROUPS_TTL) return _groupsCache;
+  const g = await getAllGroups();
+  _groupsCache = g;
+  _groupsCacheAt = Date.now();
+  return _groupsCache;
+}
 
-  const userGroups = await groups.getUserGroups([uid]);
-  const excluded = (userGroups[0] || []).some(g => excludedGroups.includes(g.name));
+// ── Exclusion cache (per uid, 30s TTL) ─────────────────────────────────────
 
-  _excludedCache.set(uid, { at: now, excluded });
-  // petite hygiene : éviter une map qui grossit sans limite
-  if (_excludedCache.size > 5000) _excludedCache.clear();
+const _excludedCache = new Map(); // uid -> { v:boolean, t:number, sig:string }
+const EXCLUDED_TTL = 30_000;
+const EXCLUDED_MAX = 10_000;
 
-  return excluded;
+function excludedSig(excludedGroups) {
+  // signature stable to invalidate when groups list changes
+  return excludedGroups.join('\u0001');
 }
 
+async function isUserExcludedCached(uid, excludedGroups) {
+  if (!uid || !excludedGroups.length) return false;
+  const now = Date.now();
+  const sig = excludedSig(excludedGroups);
+  const hit = _excludedCache.get(uid);
+  if (hit && hit.sig === sig && (now - hit.t) < EXCLUDED_TTL) return hit.v;
+  const v = await isUserExcluded(uid, excludedGroups);
+  if (_excludedCache.size > EXCLUDED_MAX) _excludedCache.clear();
+  _excludedCache.set(uid, { v, t: now, sig });
+  return v;
+}
+// ── Scripts Ezoic ──────────────────────────────────────────────────────────
+
+const EZOIC_SCRIPTS = `<script data-cfasync="false" src="https://cmp.gatekeeperconsent.com/min.js"></script>
+<script data-cfasync="false" src="https://the.gatekeeperconsent.com/cmp.min.js"></script>
+<script async src="//www.ezojs.com/ezoic/sa.min.js"></script>
+<script>
+window.ezstandalone = window.ezstandalone || {};
+ezstandalone.cmd = ezstandalone.cmd || [];
+</script>`;
+
+// ── Hooks ──────────────────────────────────────────────────────────────────
 
 plugin.onSettingsSet = function (data) {
-  // Invalider le cache dès que les settings de ce plugin sont sauvegardés via l'ACP
-  if (data && data.hash === SETTINGS_KEY) {
-    _settingsCache = null;
-    _excludedCache.clear();
-  }
+  if (data && data.hash === SETTINGS_KEY) { _settingsCache = null; _groupsCache = null; _excludedCache.clear(); }
 };
 
-
 plugin.addAdminNavigation = async (header) => {
   header.plugins = header.plugins || [];
-  header.plugins.push({
-    route: '/plugins/ezoic-infinite',
-    icon: 'fa-ad',
-    name: 'Ezoic Infinite Ads'
-  });
+  header.plugins.push({ route: '/plugins/ezoic-infinite', icon: 'fa-ad', name: 'Ezoic Infinite Ads' });
   return header;
 };
 
-plugin.init = async ({ router, middleware }) => {
-  async function render(req, res) {
+/**
+ * Injecte les scripts Ezoic dans le <head> via templateData.customHTML.
+ *
+ * NodeBB v4 / thème Harmony : header.tpl contient {{customHTML}} dans le <head>
+ * (render.js ligne 232 : templateValues.customHTML = meta.config.customHTML).
+ * Le hook filter:middleware.renderHeader reçoit templateData = headerFooterData
+ * et est rendu via req.app.renderAsync('header', hookReturn.templateData).
+ * On préfixe customHTML pour que nos scripts passent AVANT le customHTML admin,
+ * tout en préservant ce dernier.
+ */
+plugin.injectEzoicHead = async (data) => {
+  try {
     const settings = await getSettings();
-    const allGroups = await getAllGroups();
+    const uid      = data.req?.uid ?? 0;
+    const excluded = await isUserExcludedCached(uid, settings.excludedGroups);
+    if (!excluded) {
+      // Préfixer : nos scripts d'abord, puis le customHTML existant de l'admin
+      data.templateData.customHTML = EZOIC_SCRIPTS + (data.templateData.customHTML || '');
+    }
+  } catch (_) {}
+  return data;
+};
 
+plugin.init = async ({ router, middleware }) => {
+  async function render(req, res) {
+    const settings  = await getSettings();
+    const allGroups = await getAllGroupsCached();
     res.render('admin/plugins/ezoic-infinite', {
       title: 'Ezoic Infinite Ads',
       ...settings,
       enableBetweenAds_checked: settings.enableBetweenAds ? 'checked' : '',
-      enableMessageAds_checked: settings.enableMessageAds ? 'checked' : '',
+      enableMessageAds_checked:  settings.enableMessageAds  ? 'checked' : '',
       allGroups,
     });
   }
 
-  router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, render);
+  router.get('/admin/plugins/ezoic-infinite',     middleware.admin.buildHeader, render);
   router.get('/api/admin/plugins/ezoic-infinite', render);
 
   router.get('/api/plugins/ezoic-infinite/config', async (req, res) => {
     const settings = await getSettings();
-    const excluded = await isUserExcluded(req.uid, settings.excludedGroups);
-
+    const excluded = await isUserExcludedCached(req.uid, settings.excludedGroups);
     res.json({
       excluded,
-      enableBetweenAds: settings.enableBetweenAds,
-      showFirstTopicAd: settings.showFirstTopicAd,
-      placeholderIds: settings.placeholderIds,
-      intervalPosts: settings.intervalPosts,
-      enableCategoryAds: settings.enableCategoryAds,
-      showFirstCategoryAd: settings.showFirstCategoryAd,
+      enableBetweenAds:       settings.enableBetweenAds,
+      showFirstTopicAd:       settings.showFirstTopicAd,
+      placeholderIds:         settings.placeholderIds,
+      intervalPosts:          settings.intervalPosts,
+      enableCategoryAds:      settings.enableCategoryAds,
+      showFirstCategoryAd:    settings.showFirstCategoryAd,
       categoryPlaceholderIds: settings.categoryPlaceholderIds,
-      intervalCategories: settings.intervalCategories,
-      enableMessageAds: settings.enableMessageAds,
-      showFirstMessageAd: settings.showFirstMessageAd,
-      messagePlaceholderIds: settings.messagePlaceholderIds,
-      messageIntervalPosts: settings.messageIntervalPosts,
+      intervalCategories:     settings.intervalCategories,
+      enableMessageAds:       settings.enableMessageAds,
+      showFirstMessageAd:     settings.showFirstMessageAd,
+      messagePlaceholderIds:  settings.messagePlaceholderIds,
+      messageIntervalPosts:   settings.messageIntervalPosts,
     });
   });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.8.16",
+  "version": "1.8.18",
   "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",
@@ -18,4 +18,4 @@
     "compatibility": "^4.0.0"
   },
   "private": false
-}
+}

package/plugin.json

@@ -4,30 +4,14 @@
   "description": "Ezoic ads with infinite scroll using a pool of placeholder IDs",
   "library": "./library.js",
   "hooks": [
-    {
-      "hook": "static:app.load",
-      "method": "init"
-    },
-    {
-      "hook": "filter:admin.header.build",
-      "method": "addAdminNavigation"
-    },
-    {
-      "hook": "action:settings.set",
-      "method": "onSettingsSet"
-    }
+    { "hook": "static:app.load",              "method": "init"                },
+    { "hook": "filter:admin.header.build",    "method": "addAdminNavigation"  },
+    { "hook": "action:settings.set",          "method": "onSettingsSet"       },
+    { "hook": "filter:middleware.renderHeader","method": "injectEzoicHead"     }
   ],
-  "staticDirs": {
-    "public": "public"
-  },
-  "acpScripts": [
-    "public/admin.js"
-  ],
-  "scripts": [
-    "public/client.js"
-  ],
-  "templates": "public/templates",
-  "css": [
-    "public/style.css"
-  ]
-}
+  "staticDirs": { "public": "public" },
+  "acpScripts":  [ "public/admin.js"  ],
+  "scripts":     [ "public/client.js" ],
+  "templates":   "public/templates",
+  "css":         [ "public/style.css" ]
+}

package/public/client.js

@@ -1,55 +1,90 @@
 /**
- * NodeBB Ezoic Infinite Ads — client.js (v20)
+ * NodeBB Ezoic Infinite Ads — client.js v36
  *
- * 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).
+ * Historique des corrections majeures
+ * ────────────────────────────────────
+ * v18  Ancrage stable par data-pid / data-index au lieu d'ordinalMap fragile.
  *
- * [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.
+ * v19  Intervalle global basé sur l'ordinal absolu (data-index), pas sur
+ *      la position dans le batch courant.
  *
- * [BUG] injectBetween : `break` sur pool épuisé empêchait d'observer les wraps
- *   existants sur les items suivants. Fix : `continue` au lieu de `break`.
+ * v20  Table KIND : anchorAttr / ordinalAttr / baseTag par kindClass.
+ *      Fix fatal catégories : data-cid au lieu de data-index inexistant.
+ *      IO fixe (une instance, jamais recréée).
+ *      Fix TCF locator : MutationObserver recrée l'iframe si ajaxify la retire.
  *
- * [PERF] IntersectionObserver recréé à chaque scroll boost → très coûteux mobile.
- *   Fix : marge large fixe par device, observer créé une seule fois.
+ * v25  Fix scroll-up / virtualisation NodeBB : decluster + grace period.
  *
- * [PERF] Burst cooldown 100ms trop court sur mobile → rafales en cascade.
- *   Fix : 200ms.
+ * v26  Suppression définitive du recyclage d'id (causait réinjection en haut).
  *
- * 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é)
+ * v27  pruneOrphans supprimé (faux-orphelins sur virtualisation NodeBB posts).
+ *
+ * v28  decluster supprimé. Wraps persistants pendant la session.
+ *
+ * v32  Retour anchorAttr = data-index pour ezoic-ad-between.
+ *      data-tid peut être absent → clés invalides → wraps empilés.
+ *      pruneOrphansBetween réactivé uniquement pour topics de catégorie :
+ *        – NodeBB NE virtualise PAS les topics dans une liste de catégorie,
+ *          les ancres (data-index) restent en DOM → prune safe et nécessaire
+ *          pour éviter l'empilement après scroll long.
+ *        – Toujours désactivé pour les posts : NodeBB virtualise les posts
+ *          hors-viewport → faux-orphelins → bug réinjection en haut.
+ *
+ * v34  moveDistantWrap — voir v38.
+ *
+ * v50  Suppression de bindLoginCheck() : NodeBB fait un rechargement complet
+ *      après login — filter:middleware.renderHeader re-évalue l'exclusion au
+ *      rechargement. Redondant depuis le fix normalizeExcludedGroups (v49).
+ *
+ * v43  Seuil de recyclage abaissé à -vh + unobserve avant recyclage.
+ *
+ * v42  Seuil -(IO_MARGIN + vh) (trop strict, peu de wraps éligibles).
+ *
+ * v41  Seuil -1vh (trop permissif sur mobile, ignorait IO_MARGIN).
+ *
+ * v40  Recyclage slots via destroyPlaceholders+define+displayMore avec délais.
+ *      Séquence : destroy → 300ms → define → 300ms → displayMore.
+ *      Testé manuellement : fonctionne. displayMore = API Ezoic infinite scroll.
+ *
+ * v38  Pool épuisé = fin de quota Ezoic par page-view. ez.refresh() interdit
+ *      sur la même page que ez.enable() — supprimé. moveDistantWrap supprimé :
+ *      déplacer un wrap "already defined" ne re-sert aucune pub. Pool épuisé →
+ *      break propre dans injectBetween. muteConsole : ajout warnings refresh.
+ *
+ * v36  Optimisations chemin critique (scroll → injectBetween) :
+ *      – S.wrapByKey Map<anchorKey,wrap> : findWrap() passe de querySelector
+ *        sur tout le doc à un lookup O(1). Mis à jour dans insertAfter,
+ *        dropWrap et cleanup.
+ *      – wrapIsLive allégé : pour les voisins immédiats on vérifie les
+ *        attributs du nœud lui-même sans querySelector global.
+ *      – MutationObserver : matches() vérifié avant querySelector() pour
+ *        court-circuiter les sous-arbres entiers ajoutés par NodeBB.
+ *
+ * v35  Revue complète prod-ready :
+ *      – initPools protégé contre ré-initialisation inutile (S.poolsReady).
+ *      – muteConsole élargit à "No valid placeholders for loadMore".
+ *      – Commentaires et historique nettoyés.
  */
-(function () {
+(function nbbEzoicInfinite() {
   'use strict';
 
   // ── Constantes ─────────────────────────────────────────────────────────────
 
-  const WRAP_CLASS         = 'nodebb-ezoic-wrap';
-  const PH_PREFIX          = 'ezoic-pub-ad-placeholder-';
-  const A_ANCHOR           = 'data-ezoic-anchor';   // "kindClass:stableId"
-  const A_WRAPID           = 'data-ezoic-wrapid';   // id Ezoic (number string)
-  const A_CREATED          = 'data-ezoic-created';  // timestamp création (ms)
-  const A_SHOWN            = 'data-ezoic-shown';    // timestamp dernier showAds (ms)
-
-  const MIN_PRUNE_AGE_MS   = 8_000;   // délai avant qu'un wrap puisse être purgé
-  const FILL_GRACE_MS      = 25_000;  // fenêtre post-showAds où l'on ne decluster pas
-  const EMPTY_CHECK_MS     = 20_000;  // délai avant de marquer un wrap vide
-  const MAX_INSERTS_PER_RUN = 6;
-  const MAX_INFLIGHT        = 4;
-  const SHOW_THROTTLE_MS    = 900;
-  const BURST_COOLDOWN_MS   = 200;
-
-  // Marges IO larges et fixes (pas de reconstruction d'observer)
+  const WRAP_CLASS  = 'nodebb-ezoic-wrap';
+  const PH_PREFIX   = 'ezoic-pub-ad-placeholder-';
+  const A_ANCHOR    = 'data-ezoic-anchor';   // "kindClass:stableId"
+  const A_WRAPID    = 'data-ezoic-wrapid';   // id Ezoic
+  const A_CREATED   = 'data-ezoic-created';  // timestamp création ms
+  const A_SHOWN     = 'data-ezoic-shown';    // timestamp dernier showAds ms
+
+  const EMPTY_CHECK_MS    = 20_000;  // délai avant collapse d'un wrap vide post-show
+  const MIN_PRUNE_AGE_MS  = 8_000;   // délai de grâce avant pruning (stabilisation DOM)
+  const MAX_INSERTS_RUN   = 6;       // max insertions par appel runCore
+  const MAX_INFLIGHT      = 4;       // max showAds() simultanés
+  const SHOW_THROTTLE_MS  = 900;     // anti-spam showAds() par id
+  const BURST_COOLDOWN_MS = 200;     // délai min entre deux déclenchements de burst
+
+  // Marges IO larges et fixes — observer créé une seule fois au boot
   const IO_MARGIN_DESKTOP = '2500px 0px 2500px 0px';
   const IO_MARGIN_MOBILE  = '3500px 0px 3500px 0px';
 
@@ -60,42 +95,38 @@
   };
 
   /**
-   * Table centrale : kindClass → { selector DOM, attribut d'ancre stable }
+   * Table KIND — source de vérité par kindClass.
    *
-   * 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
+   * sel         sélecteur CSS complet des éléments cibles
+   * baseTag     préfixe tag pour querySelector d'ancre
+   *             (vide pour posts : le sélecteur commence par '[')
+   * anchorAttr  attribut DOM stable → clé unique du wrap
+   * ordinalAttr attribut 0-based pour le calcul de l'intervalle
+   *             null → fallback positionnel (catégories)
    */
   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'   },
+    'ezoic-ad-message':    { sel: SEL.post,     baseTag: '',   anchorAttr: 'data-pid',   ordinalAttr: 'data-index' },
+    'ezoic-ad-between':    { sel: SEL.topic,    baseTag: 'li', anchorAttr: 'data-index', ordinalAttr: 'data-index' },
+    'ezoic-ad-categories': { sel: SEL.category, baseTag: 'li', anchorAttr: 'data-cid',   ordinalAttr: null         },
   };
 
-  // ── État ───────────────────────────────────────────────────────────────────
+  // ── État global ────────────────────────────────────────────────────────────
 
   const S = {
-    pageKey: null,
-    cfg: null,
-    poolSig: null,
-
-    pools:      { topics: [], posts: [], categories: [] },
-    cursors:    { topics: 0,  posts: 0,  categories: 0  },
-    mountedIds: new Set(),      // IDs Ezoic actuellement dans le DOM
-    lastShow:   new Map(),      // id → timestamp dernier show
-
-    io:      null,
-    ioMargin: null,
-    domObs:  null,
-    mutGuard: 0,                // compteur internalMutation
-
-    inflight:    0,
-    pending:     [],
-    pendingSet:  new Set(),
-
+    pageKey:      null,
+    cfg:          null,
+    poolsReady:   false,
+    pools:        { topics: [], posts: [], categories: [] },
+    cursors:      { topics: 0,  posts: 0,  categories: 0  },
+    mountedIds:   new Set(),
+    lastShow:     new Map(),
+    io:           null,
+    domObs:       null,
+    mutGuard:     0,     // >0 : mutations DOM en cours (MutationObserver ignoré)
+    inflight:     0,     // showAds() en cours
+    pending:      [],    // ids en attente de slot inflight
+    pendingSet:   new Set(),
+    wrapByKey:    new Map(),  // anchorKey → wrap DOM node
     runQueued:    false,
     burstActive:  false,
     burstDeadline: 0,
@@ -104,8 +135,12 @@
   };
 
   let blockedUntil = 0;
-  const isBlocked  = () => Date.now() < blockedUntil;
-  const ts         = () => Date.now();
+
+  const ts        = () => Date.now();
+  const isBlocked = () => ts() < blockedUntil;
+  const isMobile  = () => { try { return window.innerWidth < 768; } catch (_) { return false; } };
+  const normBool  = v  => v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
+  const isFilled  = n  => !!(n?.querySelector?.('iframe, ins, img, video, [data-google-container-id]'));
 
   function mutate(fn) {
     S.mutGuard++;
@@ -123,44 +158,22 @@
     return S.cfg;
   }
 
-  function initPools(cfg) {
-    // (Perf) Ne reparse les pools que si les strings ont changé.
-    const sig = `${cfg.placeholderIds || ''}§${cfg.messagePlaceholderIds || ''}§${cfg.categoryPlaceholderIds || ''}`;
-    if (S.poolSig === sig) return;
-    S.poolSig = sig;
-
-    S.pools.topics     = parseIds(cfg.placeholderIds);
-    S.pools.posts      = parseIds(cfg.messagePlaceholderIds);
-    S.pools.categories = parseIds(cfg.categoryPlaceholderIds);
-
-    // Réinitialise les curseurs si une pool change
-    S.cursors.topics = 0;
-    S.cursors.posts = 0;
-    S.cursors.categories = 0;
-  }
-
   function parseIds(raw) {
-    // Accepte : un ID par ligne, ou séparés par virgules/espaces (ACP le mentionne).
     const out = [], seen = new Set();
-    const parts = String(raw || '')
-      .replace(/\r/g, '\n')
-      .split(/[\n\s,]+/)
-      .map(s => s.trim())
-      .filter(Boolean);
-
-    for (const v of parts) {
+    for (const v of String(raw || '').split(/[\s,]+/).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; } };
+  function initPools(cfg) {
+    if (S.poolsReady) return;
+    S.pools.topics     = parseIds(cfg.placeholderIds);
+    S.pools.posts      = parseIds(cfg.messagePlaceholderIds);
+    S.pools.categories = parseIds(cfg.categoryPlaceholderIds);
+    S.poolsReady = true;
+  }
 
   // ── Page identity ──────────────────────────────────────────────────────────
 
@@ -184,13 +197,13 @@
     return 'other';
   }
 
-  // ── DOM helpers ────────────────────────────────────────────────────────────
+  // ── Items DOM ──────────────────────────────────────────────────────────────
 
   function getPosts() {
     return Array.from(document.querySelectorAll(SEL.post)).filter(el => {
       if (!el.isConnected) return false;
       if (!el.querySelector('[component="post/content"]')) return false;
-      const p = el.parentElement?.closest('[component="post"][data-pid]');
+      const p = el.parentElement?.closest(SEL.post);
       if (p && p !== el) return false;
       return el.getAttribute('component') !== 'post/parent';
     });
@@ -199,53 +212,87 @@
   const getTopics     = () => Array.from(document.querySelectorAll(SEL.topic));
   const getCategories = () => Array.from(document.querySelectorAll(SEL.category));
 
+  // ── Wraps — détection ──────────────────────────────────────────────────────
+
+  /**
+   * Vérifie qu'un wrap a encore son ancre dans le DOM.
+   * Utilisé par adjacentWrap pour ignorer les wraps orphelins.
+   */
+  function wrapIsLive(wrap) {
+    if (!wrap?.classList?.contains(WRAP_CLASS)) return false;
+    const key = wrap.getAttribute(A_ANCHOR);
+    if (!key) return false;
+    // Lookup O(1) dans le registre — vrai si le wrap EST encore dans le registre
+    // et connecté au DOM (le registre est tenu à jour par insertAfter/dropWrap).
+    if (S.wrapByKey.get(key) === wrap) return wrap.isConnected;
+    // Fallback : registre pas encore à jour ou wrap non enregistré.
+    const colonIdx = key.indexOf(':');
+    const klass    = key.slice(0, colonIdx);
+    const anchorId = key.slice(colonIdx + 1);
+    const cfg = KIND[klass];
+    if (!cfg) return false;
+    // Optimisation : si l'ancre est un frère direct du wrap, pas besoin
+    // de querySelector global — on cherche parmi les voisins immédiats.
+    const parent = wrap.parentElement;
+    if (parent) {
+      for (const sib of parent.children) {
+        if (sib === wrap) continue;
+        try {
+          if (sib.matches(`${cfg.baseTag || ''}[${cfg.anchorAttr}="${anchorId}"]`)) {
+            return sib.isConnected;
+          }
+        } catch (_) {}
+      }
+    }
+    // Dernier recours : querySelector global
+    try {
+      const found = document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`);
+      return !!(found?.isConnected);
+    } catch (_) { return false; }
+  }
+
   function adjacentWrap(el) {
-    return !!(
-      el.nextElementSibling?.classList?.contains(WRAP_CLASS) ||
-      el.previousElementSibling?.classList?.contains(WRAP_CLASS)
-    );
+    return wrapIsLive(el.nextElementSibling) || wrapIsLive(el.previousElementSibling);
   }
 
-  // ── Ancres stables ────────────────────────────────────────────────────────
+  // ── Ancres stables ─────────────────────────────────────────────────────────
 
   /**
-   * 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.
+   * Retourne la valeur de l'attribut stable pour cet élément,
+   * ou un fallback positionnel si l'attribut est absent.
    */
-  function stableId(kindClass, el) {
-    const attr = KIND[kindClass]?.anchorAttr;
+  function stableId(klass, el) {
+    const attr = KIND[klass]?.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 (_) {}
+    let i = 0;
+    for (const s of el.parentElement?.children ?? []) {
+      if (s === el) return `i${i}`;
+      i++;
+    }
     return 'i0';
   }
 
-  const makeAnchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
+  const anchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
 
-  function findWrap(anchorKey) {
-    try {
-      return document.querySelector(
-        `.${WRAP_CLASS}[${A_ANCHOR}="${anchorKey.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"]`
-      );
-    } catch (_) { return null; }
+  function findWrap(key) {
+    const w = S.wrapByKey.get(key);
+    return (w?.isConnected) ? w : null;
   }
 
   // ── Pool ───────────────────────────────────────────────────────────────────
 
+  /**
+   * Retourne le prochain id disponible dans le pool (round-robin),
+   * ou null si tous les ids sont montés.
+   */
   function pickId(poolKey) {
     const pool = S.pools[poolKey];
+    if (!pool.length) return null;
     for (let t = 0; t < pool.length; t++) {
-      const i  = S.cursors[poolKey] % pool.length;
+      const i = S.cursors[poolKey] % pool.length;
       S.cursors[poolKey] = (S.cursors[poolKey] + 1) % pool.length;
       const id = pool[i];
       if (!S.mountedIds.has(id)) return id;
@@ -253,7 +300,69 @@
     return null;
   }
 
-  // ── Wraps DOM ──────────────────────────────────────────────────────────────
+  /**
+   * Pool épuisé : recycle un wrap loin au-dessus du viewport.
+   * Séquence avec délais (destroyPlaceholders est asynchrone) :
+   *   destroy([id]) → 300ms → define([id]) → 300ms → displayMore([id])
+   * displayMore = API Ezoic prévue pour l'infinite scroll.
+   * Priorité : wraps vides d'abord, remplis si nécessaire.
+   */
+  function recycleAndMove(klass, targetEl, newKey) {
+    const ez = window.ezstandalone;
+    if (typeof ez?.destroyPlaceholders !== 'function' ||
+        typeof ez?.define             !== 'function' ||
+        typeof ez?.displayMore        !== 'function') return null;
+
+    const vh        = window.innerHeight || 800;
+    // Seuil : -1vh (hors viewport visible). On appelle unobserve(ph) juste
+    // après pour neutraliser l'IO — plus de showAds parasite possible.
+    const threshold = -vh;
+    let bestEmpty = null, bestEmptyBottom = Infinity;
+    let bestFilled = null, bestFilledBottom = Infinity;
+
+    document.querySelectorAll(`.${WRAP_CLASS}.${klass}`).forEach(wrap => {
+      try {
+        const rect = wrap.getBoundingClientRect();
+        if (rect.bottom > threshold) return;
+        if (!isFilled(wrap)) {
+          if (rect.bottom < bestEmptyBottom) { bestEmptyBottom = rect.bottom; bestEmpty = wrap; }
+        } else {
+          if (rect.bottom < bestFilledBottom) { bestFilledBottom = rect.bottom; bestFilled = wrap; }
+        }
+      } catch (_) {}
+    });
+
+    const best = bestEmpty ?? bestFilled;
+    if (!best) return null;
+    const id = parseInt(best.getAttribute(A_WRAPID), 10);
+    if (!Number.isFinite(id)) return null;
+
+    const oldKey = best.getAttribute(A_ANCHOR);
+    // Neutraliser l'IO sur ce wrap avant déplacement — évite un showAds
+    // parasite si le nœud était encore dans la zone IO_MARGIN.
+    try { const ph = best.querySelector(`#${PH_PREFIX}${id}`); if (ph) S.io?.unobserve(ph); } catch (_) {}
+    mutate(() => {
+      best.setAttribute(A_ANCHOR,  newKey);
+      best.setAttribute(A_CREATED, String(ts()));
+      best.setAttribute(A_SHOWN,   '0');
+      best.classList.remove('is-empty');
+      const ph = best.querySelector(`#${PH_PREFIX}${id}`);
+      if (ph) ph.innerHTML = '';
+      targetEl.insertAdjacentElement('afterend', best);
+    });
+    if (oldKey && S.wrapByKey.get(oldKey) === best) S.wrapByKey.delete(oldKey);
+    S.wrapByKey.set(newKey, best);
+
+    // Délais requis : destroyPlaceholders est asynchrone en interne
+    const doDestroy = () => { try { ez.destroyPlaceholders([id]); } catch (_) {} setTimeout(doDefine,  300); };
+    const doDefine  = () => { try { ez.define([id]);              } catch (_) {} setTimeout(doDisplay, 300); };
+    const doDisplay = () => { try { ez.displayMore([id]);         } catch (_) {} };
+    try { (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doDestroy) : doDestroy(); } catch (_) {}
+
+    return { id, wrap: best };
+  }
+
+  // ── Wraps DOM — création / suppression ────────────────────────────────────
 
   function makeWrap(id, klass, key) {
     const w = document.createElement('div');
@@ -261,6 +370,7 @@
     w.setAttribute(A_ANCHOR,  key);
     w.setAttribute(A_WRAPID,  String(id));
     w.setAttribute(A_CREATED, String(ts()));
+    w.setAttribute(A_SHOWN,   '0');
     w.style.cssText = 'width:100%;display:block;';
     const ph = document.createElement('div');
     ph.id = `${PH_PREFIX}${id}`;
@@ -270,115 +380,85 @@
   }
 
   function insertAfter(el, id, klass, key) {
-    if (!el?.insertAdjacentElement) return null;
-    if (findWrap(key))            return null; // ancre déjà présente
-    if (S.mountedIds.has(id))     return null; // id déjà monté
+    if (!el?.insertAdjacentElement)                                 return null;
+    if (findWrap(key))                                              return null;
+    if (S.mountedIds.has(id))                                       return null;
     if (document.getElementById(`${PH_PREFIX}${id}`)?.isConnected) return null;
     const w = makeWrap(id, klass, key);
     mutate(() => el.insertAdjacentElement('afterend', w));
     S.mountedIds.add(id);
+    S.wrapByKey.set(key, w);
     return w;
   }
 
   function dropWrap(w) {
     try {
+      const ph = w.querySelector(`[id^="${PH_PREFIX}"]`);
+      if (ph instanceof Element) S.io?.unobserve(ph);
       const id = parseInt(w.getAttribute(A_WRAPID), 10);
       if (Number.isFinite(id)) S.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 (_) {}
+      const key = w.getAttribute(A_ANCHOR);
+      if (key && S.wrapByKey.get(key) === w) S.wrapByKey.delete(key);
       w.remove();
     } catch (_) {}
   }
 
-  // ── Prune ──────────────────────────────────────────────────────────────────
-
-  /**
-   * Supprime les wraps dont l'élément-ancre n'est plus dans le DOM.
-   *
-   * L'ancre est retrouvée via l'attribut stable défini dans KIND[kindClass].anchorAttr.
-   * Exemples :
-   *   ezoic-ad-message    → cherche [data-pid="123"]
-   *   ezoic-ad-between    → cherche [data-index="5"]
-   *   ezoic-ad-categories → cherche [data-cid="7"]   ← fix v20
-   *
-   * On ne prune pas les wraps < MIN_PRUNE_AGE_MS (DOM pas encore stabilisé).
-   */
-  function pruneOrphans(klass) {
-    const meta = KIND[klass];
-    if (!meta) return;
-
-    // (Perf) Construire 1 set d'ancres présentes, au lieu de querySelector par wrap.
-    const present = new Set();
-    try {
-      document.querySelectorAll(meta.sel).forEach(el => {
-        const v = el.getAttribute(meta.anchorAttr);
-        if (v !== null && v !== '') present.add(String(v));
-      });
-    } catch (_) {}
+  // ── Prune (topics de catégorie uniquement) ────────────────────────────────
+  //
+  // Réactivé uniquement pour 'ezoic-ad-between' (liste de topics).
+  //
+  // Safe ici car NodeBB ne virtualise PAS les topics dans une catégorie :
+  //   les li[component="category/topic"] restent dans le DOM pendant toute
+  //   la session. Un wrap orphelin (ancre absente) signifie vraiment que le
+  //   topic a disparu. Sans ce nettoyage, les wraps s'accumulent en tête de
+  //   liste après un long scroll et bloquent les nouvelles injections.
+  //
+  // Toujours désactivé pour 'ezoic-ad-message' (posts de topic) :
+  //   NodeBB virtualise les posts hors-viewport — il les retire puis les
+  //   réinsère. pruneOrphans verrait des ancres temporairement absentes,
+  //   supprimerait les wraps, et provoquerait une réinjection en haut.
+
+  function pruneOrphansBetween() {
+    const klass = 'ezoic-ad-between';
+    const cfg   = KIND[klass];
+
+    // Build a fast lookup of existing anchors once (avoid querySelector per wrap)
+    const anchors = new Set();
+    document.querySelectorAll(`${cfg.baseTag}[${cfg.anchorAttr}]`).forEach(el => {
+      const v = el.getAttribute(cfg.anchorAttr);
+      if (v) anchors.add(String(v));
+    });
 
     document.querySelectorAll(`.${WRAP_CLASS}.${klass}`).forEach(w => {
-      if (ts() - parseInt(w.getAttribute(A_CREATED) || '0', 10) < MIN_PRUNE_AGE_MS) return;
+      const created = parseInt(w.getAttribute(A_CREATED) || '0', 10);
+      if (ts() - created < MIN_PRUNE_AGE_MS) return; // grâce post-création
 
       const key = w.getAttribute(A_ANCHOR) ?? '';
-      const sid = key.slice(klass.length + 1); // après "kindClass:"
+      const sid = key.slice(klass.length + 1); // après "ezoic-ad-between:"
       if (!sid) { mutate(() => dropWrap(w)); return; }
 
-      if (!present.has(String(sid))) mutate(() => dropWrap(w));
+      if (!anchors.has(String(sid))) mutate(() => dropWrap(w));
     });
   }
-// ── Decluster ──────────────────────────────────────────────────────────────
-
-  /**
-   * Deux wraps adjacents = situation anormale → supprimer le moins prioritaire.
-   * Priorité : filled > en grâce (fill en cours) > vide.
-   * Ne supprime jamais un wrap dont showAds() date de moins de FILL_GRACE_MS.
-   */
-  function decluster(klass) {
-    for (const w of document.querySelectorAll(`.${WRAP_CLASS}.${klass}`)) {
-      // Grace sur le wrap courant : on le saute entièrement
-      const wShown = parseInt(w.getAttribute(A_SHOWN) || '0', 10);
-      if (wShown && ts() - wShown < FILL_GRACE_MS) continue;
-
-      let prev = w.previousElementSibling, steps = 0;
-      while (prev && steps++ < 3) {
-        if (!prev.classList?.contains(WRAP_CLASS)) { prev = prev.previousElementSibling; continue; }
-
-        const pShown = parseInt(prev.getAttribute(A_SHOWN) || '0', 10);
-        if (pShown && ts() - pShown < FILL_GRACE_MS) break; // précédent en grâce → rien
-
-        if      (!isFilled(w))    mutate(() => dropWrap(w));
-        else if (!isFilled(prev)) mutate(() => dropWrap(prev));
-        break;
-      }
-    }
-  }
 
   // ── Injection ──────────────────────────────────────────────────────────────
 
   /**
-   * Ordinal 0-based pour le calcul de l'intervalle.
-   * Pour posts/topics : data-index (NodeBB 3+/4+, toujours présent).
-   * Pour catégories : position dans le parent (page statique, pas d'infinite scroll).
+   * Ordinal 0-based pour le calcul de l'intervalle d'injection.
+   * Utilise ordinalAttr si défini, sinon compte les frères dans le parent.
    */
   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 (_) {}
+    const attr = KIND[klass]?.ordinalAttr;
+    if (attr) {
+      const v = el.getAttribute(attr);
+      if (v !== null && v !== '' && !isNaN(v)) return parseInt(v, 10);
+    }
+    const fullSel = KIND[klass]?.sel ?? '';
+    let i = 0;
+    for (const s of el.parentElement?.children ?? []) {
+      if (s === el) return i;
+      if (!fullSel || s.matches?.(fullSel)) i++;
+    }
     return 0;
   }
 
@@ -387,23 +467,25 @@
     let inserted = 0;
 
     for (const el of items) {
-      if (inserted >= MAX_INSERTS_PER_RUN) break;
+      if (inserted >= MAX_INSERTS_RUN) break;
       if (!el?.isConnected) continue;
 
-      const ord      = ordinal(klass, el);
-      const isTarget = (showFirst && ord === 0) || ((ord + 1) % interval === 0);
-      if (!isTarget) continue;
-
+      const ord = ordinal(klass, el);
+      if (!(showFirst && ord === 0) && (ord + 1) % interval !== 0) continue;
       if (adjacentWrap(el)) continue;
 
-      const key = makeAnchorKey(klass, el);
-      if (findWrap(key)) continue; // déjà là → pas de pickId inutile
+      const key = anchorKey(klass, el);
+      if (findWrap(key)) continue;
 
       const id = pickId(poolKey);
-      if (!id) continue; // pool momentanément épuisé, on continue (items suivants ≠ besoin d'id)
-
-      const w = insertAfter(el, id, klass, key);
-      if (w) { observePh(id); inserted++; }
+      if (id) {
+        const w = insertAfter(el, id, klass, key);
+        if (w) { observePh(id); inserted++; }
+      } else {
+        const recycled = recycleAndMove(klass, el, key);
+        if (!recycled) break;
+        inserted++;
+      }
     }
     return inserted;
   }
@@ -411,14 +493,7 @@
   // ── IntersectionObserver & Show ────────────────────────────────────────────
 
   function getIO() {
-    const margin = isMobile() ? IO_MARGIN_MOBILE : IO_MARGIN_DESKTOP;
-    if (S.io && S.ioMargin === margin) return S.io;
-    // Si la marge doit changer (resize/orientation), on recrée l'observer.
-    if (S.io && S.ioMargin !== margin) {
-      try { S.io.disconnect(); } catch (_) {}
-      S.io = null;
-    }
-    S.ioMargin = margin;
+    if (S.io) return S.io;
     try {
       S.io = new IntersectionObserver(entries => {
         for (const e of entries) {
@@ -427,7 +502,7 @@
           const id = parseInt(e.target.getAttribute('data-ezoic-id'), 10);
           if (Number.isFinite(id) && id > 0) enqueueShow(id);
         }
-      }, { root: null, rootMargin: margin, threshold: 0 });
+      }, { root: null, rootMargin: isMobile() ? IO_MARGIN_MOBILE : IO_MARGIN_DESKTOP, threshold: 0 });
     } catch (_) { S.io = null; }
     return S.io;
   }
@@ -478,7 +553,6 @@
         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 || {};
@@ -499,7 +573,6 @@
         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 (_) {}
@@ -507,6 +580,10 @@
   }
 
   // ── Patch Ezoic showAds ────────────────────────────────────────────────────
+  //
+  // Intercepte ez.showAds() pour :
+  //   – ignorer les appels pendant blockedUntil
+  //   – filtrer les ids dont le placeholder n'est pas en DOM
 
   function patchShowAds() {
     const apply = () => {
@@ -518,7 +595,7 @@
         const orig = ez.showAds.bind(ez);
         ez.showAds = function (...args) {
           if (isBlocked()) return;
-          const ids = (args.length === 1 && Array.isArray(args[0])) ? args[0] : args;
+          const ids  = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
           const seen = new Set();
           for (const v of ids) {
             const id = parseInt(v, 10);
@@ -537,7 +614,7 @@
     }
   }
 
-  // ── Core run ───────────────────────────────────────────────────────────────
+  // ── Core ───────────────────────────────────────────────────────────────────
 
   async function runCore() {
     if (isBlocked()) return 0;
@@ -552,30 +629,30 @@
 
     const exec = (klass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
       if (!normBool(cfgEnable)) return 0;
-      const items    = getItems();
       const interval = Math.max(1, parseInt(cfgInterval, 10) || 3);
-      pruneOrphans(klass);
-      const n = injectBetween(klass, items, interval, normBool(cfgShowFirst), poolKey);
-      if (n) decluster(klass);
-      return n;
+      return injectBetween(klass, getItems(), interval, normBool(cfgShowFirst), poolKey);
     };
 
     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(
+
+    if (kind === 'categoryTopics') {
+      pruneOrphansBetween();
+      return exec(
+        'ezoic-ad-between', getTopics,
+        cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics'
+      );
+    }
+
+    return exec(
       'ezoic-ad-categories', getCategories,
       cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories'
     );
-    return 0;
   }
 
-  // ── Scheduler / Burst ──────────────────────────────────────────────────────
+  // ── Scheduler ──────────────────────────────────────────────────────────────
 
   function scheduleRun(cb) {
     if (S.runQueued) return;
@@ -593,10 +670,8 @@
     if (isBlocked()) return;
     const t = ts();
     if (t - S.lastBurstTs < BURST_COOLDOWN_MS) return;
-    S.lastBurstTs = t;
-
-    const pk = pageKey();
-    S.pageKey      = pk;
+    S.lastBurstTs   = t;
+    S.pageKey       = pageKey();
     S.burstDeadline = t + 2000;
 
     if (S.burstActive) return;
@@ -604,7 +679,7 @@
     S.burstCount  = 0;
 
     const step = () => {
-      if (pageKey() !== pk || isBlocked() || ts() > S.burstDeadline || S.burstCount >= 8) {
+      if (pageKey() !== S.pageKey || isBlocked() || ts() > S.burstDeadline || S.burstCount >= 8) {
         S.burstActive = false; return;
       }
       S.burstCount++;
@@ -616,17 +691,18 @@
     step();
   }
 
-  // ── Cleanup (navigation ajaxify) ───────────────────────────────────────────
+  // ── Cleanup navigation ─────────────────────────────────────────────────────
 
   function cleanup() {
     blockedUntil = ts() + 1500;
     mutate(() => document.querySelectorAll(`.${WRAP_CLASS}`).forEach(dropWrap));
     S.cfg          = null;
-    S.poolSig       = null;
+    S.poolsReady   = false;
     S.pools        = { topics: [], posts: [], categories: [] };
     S.cursors      = { topics: 0, posts: 0, categories: 0 };
     S.mountedIds.clear();
     S.lastShow.clear();
+    S.wrapByKey.clear();
     S.inflight     = 0;
     S.pending      = [];
     S.pendingSet.clear();
@@ -634,19 +710,19 @@
     S.runQueued    = false;
   }
 
-  // ── DOM Observer ───────────────────────────────────────────────────────────
+  // ── MutationObserver ───────────────────────────────────────────────────────
 
   function ensureDomObserver() {
     if (S.domObs) return;
+    const allSel = [SEL.post, SEL.topic, SEL.category];
     S.domObs = new MutationObserver(muts => {
       if (S.mutGuard > 0 || isBlocked()) return;
       for (const m of muts) {
-        if (!m.addedNodes?.length) continue;
         for (const n of m.addedNodes) {
           if (n.nodeType !== 1) continue;
-          if (n.matches?.(SEL.post)     || n.querySelector?.(SEL.post)     ||
-              n.matches?.(SEL.topic)    || n.querySelector?.(SEL.topic)    ||
-              n.matches?.(SEL.category) || n.querySelector?.(SEL.category)) {
+          // matches() d'abord (O(1)), querySelector() seulement si nécessaire
+          if (allSel.some(s => { try { return n.matches(s); } catch(_){return false;} }) ||
+              allSel.some(s => { try { return !!n.querySelector(s); } catch(_){return false;} })) {
             requestBurst(); return;
           }
         }
@@ -660,7 +736,14 @@
   function muteConsole() {
     if (window.__nbbEzMuted) return;
     window.__nbbEzMuted = true;
-    const MUTED = ['[EzoicAds JS]: Placeholder Id', 'Debugger iframe already exists', `with id ${PH_PREFIX}`];
+    const MUTED = [
+      '[EzoicAds JS]: Placeholder Id',
+      'No valid placeholders for loadMore',
+      'cannot call refresh on the same page',
+      'no placeholders are currently defined in Refresh',
+      'Debugger iframe already exists',
+      `with id ${PH_PREFIX}`,
+    ];
     for (const m of ['log', 'info', 'warn', 'error']) {
       const orig = console[m];
       if (typeof orig !== 'function') continue;
@@ -672,29 +755,18 @@
   }
 
   function ensureTcfLocator() {
-    // Le CMP utilise une iframe nommée __tcfapiLocator pour router les
-    // postMessage TCF. En navigation ajaxify, NodeBB peut retirer cette
-    // iframe du DOM (vidage partiel du body), ce qui provoque :
-    //   "Cannot read properties of null (reading 'postMessage')"
-    //   "Cannot set properties of null (setting 'addtlConsent')"
-    // Solution : la recrée immédiatement si elle disparaît, via un observer.
     try {
       if (!window.__tcfapi && !window.__cmp) return;
-
       const inject = () => {
         if (document.getElementById('__tcfapiLocator')) return;
         const f = document.createElement('iframe');
         f.style.display = 'none'; f.id = f.name = '__tcfapiLocator';
         (document.body || document.documentElement).appendChild(f);
       };
-
       inject();
-
-      // Observer dédié — si quelqu'un retire l'iframe, on la remet.
       if (!window.__nbbTcfObs) {
-        window.__nbbTcfObs = new MutationObserver(() => inject());
-        window.__nbbTcfObs.observe(document.documentElement,
-          { childList: true, subtree: true });
+        window.__nbbTcfObs = new MutationObserver(inject);
+        window.__nbbTcfObs.observe(document.documentElement, { childList: true, subtree: true });
       }
     } catch (_) {}
   }
@@ -704,10 +776,10 @@
     const head = document.head;
     if (!head) return;
     for (const [rel, href, cors] of [
-      ['preconnect',   'https://g.ezoic.net',                    true],
-      ['preconnect',   'https://go.ezoic.net',                   true],
-      ['preconnect',   'https://securepubads.g.doubleclick.net', true],
-      ['preconnect',   'https://pagead2.googlesyndication.com',  true],
+      ['preconnect',   'https://g.ezoic.net',                    true ],
+      ['preconnect',   'https://go.ezoic.net',                   true ],
+      ['preconnect',   'https://securepubads.g.doubleclick.net', true ],
+      ['preconnect',   'https://pagead2.googlesyndication.com',  true ],
       ['dns-prefetch', 'https://g.ezoic.net',                    false],
       ['dns-prefetch', 'https://securepubads.g.doubleclick.net', false],
     ]) {
@@ -721,7 +793,7 @@
     }
   }
 
-  // ── Bindings NodeBB ────────────────────────────────────────────────────────
+  // ── Bindings ───────────────────────────────────────────────────────────────
 
   function bindNodeBB() {
     const $ = window.jQuery;
@@ -732,19 +804,16 @@
     $(window).on('action:ajaxify.end.nbbEzoic', () => {
       S.pageKey    = pageKey();
       blockedUntil = 0;
-      muteConsole(); ensureTcfLocator(); warmNetwork(); patchShowAds();
-      getIO(); ensureDomObserver(); requestBurst();
+      muteConsole(); ensureTcfLocator(); warmNetwork();
+      patchShowAds(); getIO(); ensureDomObserver(); requestBurst();
     });
 
-    const BURST_EVENTS = [
-      'action:ajaxify.contentLoaded',
-      'action:posts.loaded', 'action:topics.loaded',
+    const burstEvts = [
+      'action:ajaxify.contentLoaded', 'action:posts.loaded', 'action:topics.loaded',
       'action:categories.loaded', 'action:category.loaded', 'action:topic.loaded',
     ].map(e => `${e}.nbbEzoic`).join(' ');
+    $(window).on(burstEvts, () => { if (!isBlocked()) requestBurst(); });
 
-    $(window).on(BURST_EVENTS, () => { if (!isBlocked()) requestBurst(); });
-
-    // Hooks AMD (NodeBB 4.x — redondant avec jQuery events mais sans risque)
     try {
       require(['hooks'], hooks => {
         if (typeof hooks?.on !== 'function') return;
@@ -756,22 +825,6 @@
     } catch (_) {}
   }
 
-
-  function bindResize() {
-    let t = null;
-    window.addEventListener('resize', () => {
-      clearTimeout(t);
-      t = setTimeout(() => {
-        try { getIO(); } catch (_) {}
-        // Ré-observer les placeholders existants (si IO recréé)
-        try {
-          document.querySelectorAll(`.${WRAP_CLASS} [id^="${PH_PREFIX}"]`).forEach(ph => {
-            if (ph instanceof Element) { try { S.io?.observe(ph); } catch (_) {} }
-          });
-        } catch (_) {}
-      }, 200);
-    }, { passive: true });
-  }
   function bindScroll() {
     let ticking = false;
     window.addEventListener('scroll', () => {
@@ -791,7 +844,6 @@
   getIO();
   ensureDomObserver();
   bindNodeBB();
-  bindResize();
   bindScroll();
   blockedUntil = 0;
   requestBurst();