nodebb-plugin-ezoic-infinite 1.8.18 → 1.8.20

package/library.js

@@ -1,198 +1,205 @@
 '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 = {};
+const SETTINGS_TTL_MS = 30_000;
 
-// ── Helpers ────────────────────────────────────────────────────────────────
+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>`;
 
-function normalizeExcludedGroups(value) {
-  if (!value) return [];
-  if (Array.isArray(value)) return value;
-  // 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 (_) {}
+const DEFAULTS = Object.freeze({
+  enableBetweenAds: true,
+  showFirstTopicAd: false,
+  placeholderIds: '',
+  intervalPosts: 6,
+  enableCategoryAds: false,
+  showFirstCategoryAd: false,
+  categoryPlaceholderIds: '',
+  intervalCategories: 4,
+  enableMessageAds: false,
+  showFirstMessageAd: false,
+  messagePlaceholderIds: '',
+  messageIntervalPosts: 3,
+  excludedGroups: [],
+});
+
+const CONFIG_FIELDS = Object.freeze([
+  'enableBetweenAds', 'showFirstTopicAd', 'placeholderIds', 'intervalPosts',
+  'enableCategoryAds', 'showFirstCategoryAd', 'categoryPlaceholderIds', 'intervalCategories',
+  'enableMessageAds', 'showFirstMessageAd', 'messagePlaceholderIds', 'messageIntervalPosts',
+]);
+
+const plugin = {
+  _settingsCache: null,
+  _settingsCacheAt: 0,
+};
+
+function toBool(value, fallback = false) {
+  if (value === undefined || value === null || value === '') return fallback;
+  if (typeof value === 'boolean') return value;
+  switch (String(value).trim().toLowerCase()) {
+    case '1':
+    case 'true':
+    case 'on':
+    case 'yes':
+      return true;
+    default:
+      return false;
   }
-  // Fallback : séparation par virgule
-  return s.split(',').map(v => v.trim()).filter(Boolean);
 }
 
-function parseBool(v, def = false) {
-  if (v === undefined || v === null || v === '') return def;
-  if (typeof v === 'boolean') return v;
-  const s = String(v).toLowerCase();
-  return s === '1' || s === 'true' || s === 'on' || s === 'yes';
+function toPositiveInt(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
-async function getAllGroups() {
-  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);
-  valid.sort((a, b) => String(a.name).localeCompare(String(b.name), undefined, { sensitivity: 'base' }));
-  return valid;
+function toStringTrim(value) {
+  return typeof value === 'string' ? value.trim() : '';
 }
 
-// ── Settings cache (30s TTL) ────────────────────────────────────────────────
+function normalizeExcludedGroups(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) {
+    return value.map(String).map(v => v.trim()).filter(Boolean);
+  }
 
-let _settingsCache   = null;
-let _settingsCacheAt = 0;
-const SETTINGS_TTL   = 30_000;
+  const raw = String(value).trim();
+  if (!raw) return [];
 
-async function getSettings() {
-  const now = Date.now();
-  if (_settingsCache && (now - _settingsCacheAt) < SETTINGS_TTL) return _settingsCache;
-  const s = await meta.settings.get(SETTINGS_KEY);
-  _settingsCacheAt = Date.now();
-  _settingsCache = {
-    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),
-    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;
-}
+  if (raw.startsWith('[')) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        return parsed.map(String).map(v => v.trim()).filter(Boolean);
+      }
+    } catch {}
+  }
 
-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));
+  return raw.split(',').map(v => v.trim()).filter(Boolean);
 }
 
+function buildSettings(raw = {}) {
+  return {
+    enableBetweenAds: toBool(raw.enableBetweenAds, DEFAULTS.enableBetweenAds),
+    showFirstTopicAd: toBool(raw.showFirstTopicAd, DEFAULTS.showFirstTopicAd),
+    placeholderIds: toStringTrim(raw.placeholderIds),
+    intervalPosts: toPositiveInt(raw.intervalPosts, DEFAULTS.intervalPosts),
+    enableCategoryAds: toBool(raw.enableCategoryAds, DEFAULTS.enableCategoryAds),
+    showFirstCategoryAd: toBool(raw.showFirstCategoryAd, DEFAULTS.showFirstCategoryAd),
+    categoryPlaceholderIds: toStringTrim(raw.categoryPlaceholderIds),
+    intervalCategories: toPositiveInt(raw.intervalCategories, DEFAULTS.intervalCategories),
+    enableMessageAds: toBool(raw.enableMessageAds, DEFAULTS.enableMessageAds),
+    showFirstMessageAd: toBool(raw.showFirstMessageAd, DEFAULTS.showFirstMessageAd),
+    messagePlaceholderIds: toStringTrim(raw.messagePlaceholderIds),
+    messageIntervalPosts: toPositiveInt(raw.messageIntervalPosts, DEFAULTS.messageIntervalPosts),
+    excludedGroups: normalizeExcludedGroups(raw.excludedGroups),
+  };
+}
 
+async function listNonPrivilegeGroups() {
+  let names = await db.getSortedSetRange('groups:createtime', 0, -1);
+  if (!Array.isArray(names) || !names.length) {
+    names = await db.getSortedSetRange('groups:visible:createtime', 0, -1);
+  }
 
-// ── Groups cache (5 min TTL) ───────────────────────────────────────────────
-
-let _groupsCache = null;
-let _groupsCacheAt = 0;
-const GROUPS_TTL = 5 * 60_000;
+  const publicNames = (names || []).filter(name => !groups.isPrivilegeGroup(name));
+  const groupData = await groups.getGroupsData(publicNames);
 
-async function getAllGroupsCached() {
-  const now = Date.now();
-  if (_groupsCache && (now - _groupsCacheAt) < GROUPS_TTL) return _groupsCache;
-  const g = await getAllGroups();
-  _groupsCache = g;
-  _groupsCacheAt = Date.now();
-  return _groupsCache;
+  return (groupData || [])
+    .filter(group => group && group.name)
+    .sort((a, b) => String(a.name).localeCompare(String(b.name), undefined, { sensitivity: 'base' }));
 }
 
-// ── Exclusion cache (per uid, 30s TTL) ─────────────────────────────────────
+async function getSettings() {
+  const now = Date.now();
+  if (plugin._settingsCache && (now - plugin._settingsCacheAt) < SETTINGS_TTL_MS) {
+    return plugin._settingsCache;
+  }
 
-const _excludedCache = new Map(); // uid -> { v:boolean, t:number, sig:string }
-const EXCLUDED_TTL = 30_000;
-const EXCLUDED_MAX = 10_000;
+  const raw = await meta.settings.get(SETTINGS_KEY);
+  const settings = buildSettings(raw);
 
-function excludedSig(excludedGroups) {
-  // signature stable to invalidate when groups list changes
-  return excludedGroups.join('\u0001');
+  plugin._settingsCache = settings;
+  plugin._settingsCacheAt = now;
+  return settings;
 }
 
-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 ──────────────────────────────────────────────────────────
+async function isUserExcluded(uid, excludedGroups) {
+  if (!uid || !Array.isArray(excludedGroups) || !excludedGroups.length) return false;
 
-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>`;
+  const userGroups = await groups.getUserGroups([uid]);
+  const names = (userGroups && userGroups[0]) || [];
+  const excludedSet = new Set(excludedGroups);
 
-// ── Hooks ──────────────────────────────────────────────────────────────────
+  return names.some(group => group && excludedSet.has(group.name));
+}
 
-plugin.onSettingsSet = function (data) {
-  if (data && data.hash === SETTINGS_KEY) { _settingsCache = null; _groupsCache = null; _excludedCache.clear(); }
+plugin.onSettingsSet = function onSettingsSet(data) {
+  if (data && data.hash === SETTINGS_KEY) {
+    plugin._settingsCache = null;
+    plugin._settingsCacheAt = 0;
+  }
 };
 
-plugin.addAdminNavigation = async (header) => {
+plugin.addAdminNavigation = async function addAdminNavigation(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;
 };
 
-/**
- * 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) => {
+plugin.injectEzoicHead = async function injectEzoicHead(data) {
   try {
     const settings = await getSettings();
-    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 || '');
+    const uid = data?.req?.uid || 0;
+    if (await isUserExcluded(uid, settings.excludedGroups)) {
+      return data;
     }
-  } catch (_) {}
+
+    const templateData = data.templateData || (data.templateData = {});
+    templateData.customHTML = `${EZOIC_SCRIPTS}${templateData.customHTML || ''}`;
+  } catch {}
+
   return data;
 };
 
-plugin.init = async ({ router, middleware }) => {
-  async function render(req, res) {
-    const settings  = await getSettings();
-    const allGroups = await getAllGroupsCached();
+plugin.init = async function init({ router, middleware }) {
+  async function renderAdmin(req, res) {
+    const [settings, allGroups] = await Promise.all([
+      getSettings(),
+      listNonPrivilegeGroups(),
+    ]);
+
     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('/api/admin/plugins/ezoic-infinite', render);
+  router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, renderAdmin);
+  router.get('/api/admin/plugins/ezoic-infinite', renderAdmin);
 
   router.get('/api/plugins/ezoic-infinite/config', async (req, res) => {
     const settings = await getSettings();
-    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,
-      categoryPlaceholderIds: settings.categoryPlaceholderIds,
-      intervalCategories:     settings.intervalCategories,
-      enableMessageAds:       settings.enableMessageAds,
-      showFirstMessageAd:     settings.showFirstMessageAd,
-      messagePlaceholderIds:  settings.messagePlaceholderIds,
-      messageIntervalPosts:   settings.messageIntervalPosts,
-    });
+    const excluded = await isUserExcluded(req.uid, settings.excludedGroups);
+
+    const payload = { excluded };
+    for (const key of CONFIG_FIELDS) payload[key] = settings[key];
+    res.json(payload);
   });
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.8.18",
+  "version": "1.8.20",
   "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/public/admin.js

@@ -1,28 +1,44 @@
 /* globals ajaxify */
 'use strict';
 
-(function () {
-  function init() {
-    const $form = $('.ezoic-infinite-settings');
-    if (!$form.length) return;
+(function initAdminEzoicSettings() {
+  const FORM_SELECTOR = '.ezoic-infinite-settings';
+  const SAVE_SELECTOR = '#save';
+  const SETTINGS_KEY = 'ezoic-infinite';
+  const EVENT_NS = '.ezoicInfinite';
+
+  function showSaved(alerts) {
+    if (alerts && typeof alerts.success === 'function') {
+      alerts.success('[[admin/settings:saved]]');
+      return;
+    }
+    if (window.app && typeof window.app.alertSuccess === 'function') {
+      window.app.alertSuccess('[[admin/settings:saved]]');
+    }
+  }
 
-    require(['settings', 'alerts'], function (Settings, alerts) {
-      Settings.load('ezoic-infinite', $form);
+  function bind(Settings, alerts, $form) {
+    Settings.load(SETTINGS_KEY, $form);
 
-      $('#save').off('click.ezoicInfinite').on('click.ezoicInfinite', function (e) {
+    $(SAVE_SELECTOR)
+      .off(`click${EVENT_NS}`)
+      .on(`click${EVENT_NS}`, function onSave(e) {
         e.preventDefault();
-
-        Settings.save('ezoic-infinite', $form, function () {
-          if (alerts && typeof alerts.success === 'function') {
-            alerts.success('[[admin/settings:saved]]');
-          } else if (window.app && typeof window.app.alertSuccess === 'function') {
-            window.app.alertSuccess('[[admin/settings:saved]]');
-          }
+        Settings.save(SETTINGS_KEY, $form, function onSaved() {
+          showSaved(alerts);
         });
       });
+  }
+
+  function boot() {
+    const $form = $(FORM_SELECTOR);
+    if (!$form.length) return;
+
+    require(['settings', 'alerts'], function onModules(Settings, alerts) {
+      bind(Settings, alerts, $form);
     });
   }
 
-  $(document).ready(init);
-  $(window).on('action:ajaxify.end', init);
+  $(document).ready(boot);
+  $(window).on('action:ajaxify.end', boot);
 })();

package/public/client.js

@@ -1,70 +1,3 @@
-/**
- * NodeBB Ezoic Infinite Ads — client.js v36
- *
- * Historique des corrections majeures
- * ────────────────────────────────────
- * v18  Ancrage stable par data-pid / data-index au lieu d'ordinalMap fragile.
- *
- * v19  Intervalle global basé sur l'ordinal absolu (data-index), pas sur
- *      la position dans le batch courant.
- *
- * 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.
- *
- * v25  Fix scroll-up / virtualisation NodeBB : decluster + grace period.
- *
- * v26  Suppression définitive du recyclage d'id (causait réinjection en haut).
- *
- * 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 nbbEzoicInfinite() {
   'use strict';
 
@@ -77,12 +10,18 @@
   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
+  // Tunables (stables en prod)
   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
+  const MAX_INSERTS_RUN   = 10;      // plus réactif si NodeBB injecte en rafale
+  const MAX_INFLIGHT      = 2;       // ids max simultanés en vol (garde-fou)
+  const MAX_SHOW_BATCH    = 4;       // ids max par appel showAds(...ids)
+  const SHOW_THROTTLE_MS  = 500;     // anti-spam showAds() par id (plus réactif)
+  const SHOW_RELEASE_MS   = 300;     // relâche inflight après showAds() batché
+  const SHOW_FAILSAFE_MS  = 7000;    // relâche forcée si stack pub lente
+  const BATCH_FLUSH_MS    = 30;      // micro-buffer pour regrouper les ids proches
+  const MAX_DESTROY_BATCH  = 4;       // ids max par destroyPlaceholders(...ids)
+  const DESTROY_FLUSH_MS   = 30;      // micro-buffer destroy pour lisser les rafales
+  const BURST_COOLDOWN_MS = 100;     // 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';
@@ -93,6 +32,9 @@
     topic:    'li[component="category/topic"]',
     category: 'li[component="categories/category"]',
   };
+  const WRAP_SEL = `.${WRAP_CLASS}`;
+  const FILL_SEL = 'iframe, ins, img, video, [data-google-container-id]';
+  const CONTENT_SEL_LIST = [SEL.post, SEL.topic, SEL.category];
 
   /**
    * Table KIND — source de vérité par kindClass.
@@ -126,7 +68,18 @@
     inflight:     0,     // showAds() en cours
     pending:      [],    // ids en attente de slot inflight
     pendingSet:   new Set(),
+    showBatchTimer: 0,
+    destroyBatchTimer: 0,
+    destroyPending: [],
+    destroyPendingSet: new Set(),
+    sweepQueued:  false,
     wrapByKey:    new Map(),  // anchorKey → wrap DOM node
+    ezActiveIds:  new Set(),  // ids actifs côté plugin (wrap présent / récemment show)
+    ezShownSinceDestroy: new Set(), // ids déjà show depuis le dernier destroy Ezoic
+    scrollDir:    1,          // 1=bas, -1=haut
+    scrollSpeed:  0,          // px/s approx (EMA)
+    lastScrollY:  0,
+    lastScrollTs: 0,
     runQueued:    false,
     burstActive:  false,
     burstDeadline: 0,
@@ -140,12 +93,121 @@
   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]'));
+  const isFilled  = n  => !!(n?.querySelector?.(FILL_SEL));
+
+  function healFalseEmpty(root = document) {
+    try {
+      const list = [];
+      if (root instanceof Element && root.classList?.contains(WRAP_CLASS)) list.push(root);
+      const found = root.querySelectorAll ? root.querySelectorAll(`.${WRAP_CLASS}.is-empty`) : [];
+      for (const w of found) list.push(w);
+      for (const w of list) {
+        if (!w?.classList?.contains('is-empty')) continue;
+        if (isFilled(w)) w.classList.remove('is-empty');
+      }
+    } catch (_) {}
+  }
+
+  function phEl(id) {
+    return document.getElementById(`${PH_PREFIX}${id}`);
+  }
+
+  function hasSinglePlaceholder(id) {
+    try { return document.querySelectorAll(`#${PH_PREFIX}${id}`).length === 1; } catch (_) { return false; }
+  }
+
+  function canShowPlaceholderId(id, now = ts()) {
+    const n = parseInt(id, 10);
+    if (!Number.isFinite(n) || n <= 0) return false;
+    if (now - (S.lastShow.get(n) ?? 0) < SHOW_THROTTLE_MS) return false;
+    const ph = phEl(n);
+    if (!ph?.isConnected || isFilled(ph)) return false;
+    if (!hasSinglePlaceholder(n)) return false;
+    return true;
+  }
+
+  function queueSweepDeadWraps() {
+    if (S.sweepQueued) return;
+    S.sweepQueued = true;
+    requestAnimationFrame(() => {
+      S.sweepQueued = false;
+      sweepDeadWraps();
+      healFalseEmpty();
+    });
+  }
+
+  function getDynamicShowBatchMax() {
+    const speed = S.scrollSpeed || 0;
+    const pend  = S.pending.length;
+    // Scroll très rapide => petits batches (réduit le churn/unused)
+    if (speed > 2600) return 2;
+    if (speed > 1400) return 3;
+    // Peu de candidats => flush plus vite, inutile d'attendre 4
+    if (pend <= 1) return 1;
+    if (pend <= 3) return 2;
+    // Par défaut compromis dynamique
+    return 3;
+  }
 
   function mutate(fn) {
     S.mutGuard++;
     try { fn(); } finally { S.mutGuard--; }
   }
+function scheduleDestroyFlush() {
+  if (S.destroyBatchTimer) return;
+  S.destroyBatchTimer = setTimeout(() => {
+    S.destroyBatchTimer = 0;
+    flushDestroyBatch();
+  }, DESTROY_FLUSH_MS);
+}
+
+function flushDestroyBatch() {
+  if (!S.destroyPending.length) return;
+  const ids = [];
+  while (S.destroyPending.length && ids.length < MAX_DESTROY_BATCH) {
+    const id = S.destroyPending.shift();
+    S.destroyPendingSet.delete(id);
+    if (!Number.isFinite(id) || id <= 0) continue;
+    ids.push(id);
+  }
+  if (ids.length) {
+    try {
+      const ez = window.ezstandalone;
+      const run = () => { try { ez?.destroyPlaceholders?.(ids); } catch (_) {} };
+      try { (typeof ez?.cmd?.push === 'function') ? ez.cmd.push(run) : run(); } catch (_) {}
+    } catch (_) {}
+  }
+  if (S.destroyPending.length) scheduleDestroyFlush();
+}
+
+function destroyEzoicId(id) {
+  if (!Number.isFinite(id) || id <= 0) return;
+  if (!S.ezActiveIds.has(id)) return;
+  S.ezActiveIds.delete(id);
+  if (!S.destroyPendingSet.has(id)) {
+    S.destroyPending.push(id);
+    S.destroyPendingSet.add(id);
+  }
+  scheduleDestroyFlush();
+}
+
+function destroyBeforeReuse(ids) {
+  const out = [];
+  const toDestroy = [];
+  const seen = new Set();
+  for (const raw of (ids || [])) {
+    const id = parseInt(raw, 10);
+    if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+    if (S.ezShownSinceDestroy.has(id)) toDestroy.push(id);
+  }
+  if (toDestroy.length) {
+    try { window.ezstandalone?.destroyPlaceholders?.(toDestroy); } catch (_) {}
+    for (const id of toDestroy) S.ezShownSinceDestroy.delete(id);
+  }
+  return out;
+}
 
   // ── Config ─────────────────────────────────────────────────────────────────
 
@@ -160,7 +222,7 @@
 
   function parseIds(raw) {
     const out = [], seen = new Set();
-    for (const v of String(raw || '').split(/[\s,]+/).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 (n > 0 && Number.isFinite(n) && !seen.has(n)) { seen.add(n); out.push(n); }
     }
@@ -300,6 +362,27 @@
     return null;
   }
 
+  function sweepDeadWraps() {
+    // NodeBB peut retirer des nœuds sans passer par dropWrap() (virtualisation / rerender).
+    // On libère alors les IDs/keys fantômes pour éviter l'épuisement du pool.
+    let changed = false;
+    for (const [key, wrap] of S.wrapByKey) {
+      if (wrap?.isConnected) continue;
+      changed = true;
+      S.wrapByKey.delete(key);
+      const id = parseInt(wrap?.getAttribute?.(A_WRAPID), 10);
+      if (Number.isFinite(id)) {
+        S.mountedIds.delete(id);
+        S.pendingSet.delete(id);
+        S.lastShow.delete(id);
+        S.ezActiveIds.delete(id);
+      }
+    }
+    if (changed && S.pending.length) {
+      S.pending = S.pending.filter(id => S.pendingSet.has(id));
+    }
+  }
+
   /**
    * Pool épuisé : recycle un wrap loin au-dessus du viewport.
    * Séquence avec délais (destroyPlaceholders est asynchrone) :
@@ -307,60 +390,83 @@
    * 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; }
+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;
+  const preferAbove = S.scrollDir >= 0; // scroll bas => recycle en haut
+  const farAbove = -vh;
+  const farBelow = vh * 2;
+
+  let bestPrefEmpty = null, bestPrefMetric = Infinity;
+  let bestPrefFilled = null, bestPrefFilledMetric = Infinity;
+  let bestAnyEmpty = null, bestAnyMetric = Infinity;
+  let bestAnyFilled = null, bestAnyFilledMetric = Infinity;
+
+  for (const wrap of S.wrapByKey.values()) {
+    if (!wrap?.isConnected || !wrap.classList?.contains(WRAP_CLASS) || !wrap.classList.contains(klass)) continue;
+    try {
+      const rect = wrap.getBoundingClientRect();
+      const isAbove = rect.bottom <= farAbove;
+      const isBelow = rect.top >= farBelow;
+      const anyFar = isAbove || isBelow;
+      if (!anyFar) continue;
+
+      const qualifies = preferAbove ? isAbove : isBelow;
+      const metric = preferAbove ? Math.abs(rect.bottom) : Math.abs(rect.top - vh);
+      const filled = isFilled(wrap);
+
+      if (qualifies) {
+        if (!filled) {
+          if (metric < bestPrefMetric) { bestPrefMetric = metric; bestPrefEmpty = wrap; }
         } else {
-          if (rect.bottom < bestFilledBottom) { bestFilledBottom = rect.bottom; bestFilled = wrap; }
+          if (metric < bestPrefFilledMetric) { bestPrefFilledMetric = metric; bestPrefFilled = 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);
+      }
+      if (!filled) {
+        if (metric < bestAnyMetric) { bestAnyMetric = metric; bestAnyEmpty = wrap; }
+      } else {
+        if (metric < bestAnyFilledMetric) { bestAnyFilledMetric = metric; bestAnyFilled = wrap; }
+      }
+    } catch (_) {}
+  }
 
-    // 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 (_) {}
+  const best = bestPrefEmpty ?? bestPrefFilled ?? bestAnyEmpty ?? bestAnyFilled;
+  if (!best) return null;
+  const id = parseInt(best.getAttribute(A_WRAPID), 10);
+  if (!Number.isFinite(id)) return null;
+
+  const oldKey = best.getAttribute(A_ANCHOR);
+  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);
+
+  const doDestroy = () => {
+    if (S.ezShownSinceDestroy.has(id)) {
+      try { ez.destroyPlaceholders([id]); } catch (_) {}
+      S.ezShownSinceDestroy.delete(id);
+    }
+    S.ezActiveIds.delete(id);
+    setTimeout(doDefine, 330);
+  };
+  const doDefine  = () => { try { ez.define([id]); } catch (_) {} setTimeout(doDisplay, 300); };
+  const doDisplay = () => { try { ez.displayMore([id]); S.ezActiveIds.add(id); S.ezShownSinceDestroy.add(id); } catch (_) {} };
+  try { (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doDestroy) : doDestroy(); } catch (_) {}
 
-    return { id, wrap: best };
-  }
+  return { id, wrap: best };
+}
 
   // ── Wraps DOM — création / suppression ────────────────────────────────────
 
@@ -396,7 +502,7 @@
       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);
+      if (Number.isFinite(id)) { S.ezActiveIds.delete(id); S.mountedIds.delete(id); }
       const key = w.getAttribute(A_ANCHOR);
       if (key && S.wrapByKey.get(key) === w) S.wrapByKey.delete(key);
       w.remove();
@@ -422,14 +528,7 @@
     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 => {
+    document.querySelectorAll(`${WRAP_SEL}.${klass}`).forEach(w => {
       const created = parseInt(w.getAttribute(A_CREATED) || '0', 10);
       if (ts() - created < MIN_PRUNE_AGE_MS) return; // grâce post-création
 
@@ -437,7 +536,8 @@
       const sid = key.slice(klass.length + 1); // après "ezoic-ad-between:"
       if (!sid) { mutate(() => dropWrap(w)); return; }
 
-      if (!anchors.has(String(sid))) mutate(() => dropWrap(w));
+      const anchorEl = document.querySelector(`${cfg.baseTag}[${cfg.anchorAttr}="${sid}"]`);
+      if (!anchorEl?.isConnected) mutate(() => dropWrap(w));
     });
   }
 
@@ -477,7 +577,8 @@
       const key = anchorKey(klass, el);
       if (findWrap(key)) continue;
 
-      const id = pickId(poolKey);
+      let id = pickId(poolKey);
+      if (!id) { sweepDeadWraps(); id = pickId(poolKey); }
       if (id) {
         const w = insertAfter(el, id, klass, key);
         if (w) { observePh(id); inserted++; }
@@ -508,76 +609,106 @@
   }
 
   function observePh(id) {
-    const ph = document.getElementById(`${PH_PREFIX}${id}`);
+    const ph = phEl(id);
     if (ph?.isConnected) try { getIO()?.observe(ph); } catch (_) {}
+    // Fast-path : si déjà proche viewport, ne pas attendre un callback IO complet
+    try {
+      if (!ph?.isConnected) return;
+      const rect = ph.getBoundingClientRect();
+      const vh = window.innerHeight || 800;
+      const preload = isMobile() ? 1400 : 1000;
+      if (rect.top <= vh + preload && rect.bottom >= -preload) enqueueShow(id);
+    } catch (_) {}
   }
 
-  function enqueueShow(id) {
-    if (!id || isBlocked()) return;
-    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);
-  }
+function enqueueShow(id) {
+  if (!id || isBlocked()) return;
+  const n = parseInt(id, 10);
+  if (!Number.isFinite(n) || n <= 0) return;
+  if (ts() - (S.lastShow.get(n) ?? 0) < SHOW_THROTTLE_MS) return;
+  if (!S.pendingSet.has(n)) { S.pending.push(n); S.pendingSet.add(n); }
+  scheduleDrainQueue();
+}
+
+function scheduleDrainQueue() {
+  if (isBlocked()) return;
+  if (S.showBatchTimer) return;
+  S.showBatchTimer = setTimeout(() => {
+    S.showBatchTimer = 0;
+    drainQueue();
+  }, BATCH_FLUSH_MS);
+}
+
+function drainQueue() {
+  if (isBlocked()) return;
+  const free = Math.max(0, MAX_INFLIGHT - S.inflight);
+  if (!free || !S.pending.length) return;
+
+  const picked = [];
+  const seen = new Set();
+  const batchCap = Math.max(1, Math.min(MAX_SHOW_BATCH, free, getDynamicShowBatchMax()));
+  while (S.pending.length && picked.length < batchCap) {
+    const id = S.pending.shift();
+    S.pendingSet.delete(id);
+    if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
+    if (!phEl(id)?.isConnected) continue;
+    seen.add(id);
+    picked.push(id);
+  }
+  if (picked.length) startShowBatch(picked);
+  if (S.pending.length && (MAX_INFLIGHT - S.inflight) > 0) scheduleDrainQueue();
+}
+
+function startShowBatch(ids) {
+  if (!ids?.length || isBlocked()) return;
+  const reserve = ids.length;
+  S.inflight += reserve;
+
+  let done = false;
+  const release = () => {
+    if (done) return;
+    done = true;
+    S.inflight = Math.max(0, S.inflight - reserve);
+    drainQueue();
+  };
+  const timer = setTimeout(release, SHOW_FAILSAFE_MS);
 
-  function drainQueue() {
-    if (isBlocked()) return;
-    while (S.inflight < MAX_INFLIGHT && S.pending.length) {
-      const id = S.pending.shift();
-      S.pendingSet.delete(id);
-      startShow(id);
-    }
-  }
+  requestAnimationFrame(() => {
+    try {
+      if (isBlocked()) { clearTimeout(timer); return release(); }
 
-  function startShow(id) {
-    if (!id || isBlocked()) return;
-    S.inflight++;
-    let done = false;
-    const release = () => {
-      if (done) return;
-      done = true;
-      S.inflight = Math.max(0, S.inflight - 1);
-      drainQueue();
-    };
-    const timer = setTimeout(release, 7000);
+      const valid = [];
+      const t = ts();
 
-    requestAnimationFrame(() => {
-      try {
-        if (isBlocked()) { clearTimeout(timer); return release(); }
-        const ph = document.getElementById(`${PH_PREFIX}${id}`);
-        if (!ph?.isConnected || isFilled(ph)) { clearTimeout(timer); return release(); }
+      for (const raw of ids) {
+        const id = parseInt(raw, 10);
+        if (!Number.isFinite(id) || id <= 0) continue;
+        const ph = phEl(id);
+        if (!canShowPlaceholderId(id, t)) continue;
 
-        const t = ts();
-        if (t - (S.lastShow.get(id) ?? 0) < SHOW_THROTTLE_MS) { clearTimeout(timer); return release(); }
         S.lastShow.set(id, t);
+        try { ph.closest?.(WRAP_SEL)?.setAttribute(A_SHOWN, String(t)); } catch (_) {}
+        valid.push(id);
+      }
 
-        try { ph.closest?.(`.${WRAP_CLASS}`)?.setAttribute(A_SHOWN, String(t)); } catch (_) {}
+      if (!valid.length) { clearTimeout(timer); return release(); }
 
-        window.ezstandalone = window.ezstandalone || {};
-        const ez = window.ezstandalone;
-        const doShow = () => {
-          try { ez.showAds(id); } catch (_) {}
-          scheduleEmptyCheck(id, t);
-          setTimeout(() => { clearTimeout(timer); release(); }, 700);
-        };
-        Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
-      } catch (_) { clearTimeout(timer); release(); }
-    });
-  }
-
-  function scheduleEmptyCheck(id, showTs) {
-    setTimeout(() => {
-      try {
-        const ph   = document.getElementById(`${PH_PREFIX}${id}`);
-        const wrap = ph?.closest?.(`.${WRAP_CLASS}`);
-        if (!wrap || !ph?.isConnected) return;
-        if (parseInt(wrap.getAttribute(A_SHOWN) || '0', 10) > showTs) return;
-        wrap.classList.toggle('is-empty', !isFilled(ph));
-      } catch (_) {}
-    }, EMPTY_CHECK_MS);
-  }
+      window.ezstandalone = window.ezstandalone || {};
+      const ez = window.ezstandalone;
+      const doShow = () => {
+        const prepared = destroyBeforeReuse(valid);
+        if (!prepared.length) { setTimeout(() => { clearTimeout(timer); release(); }, SHOW_RELEASE_MS); return; }
+        try { ez.showAds(...prepared); } catch (_) {}
+        for (const id of prepared) {
+          S.ezActiveIds.add(id);
+          S.ezShownSinceDestroy.add(id);
+        }
+        setTimeout(() => { clearTimeout(timer); release(); }, SHOW_RELEASE_MS);
+      };
+      Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
+    } catch (_) { clearTimeout(timer); release(); }
+  });
+}
 
   // ── Patch Ezoic showAds ────────────────────────────────────────────────────
   //
@@ -595,14 +726,21 @@
         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 valid = [];
           const seen = new Set();
           for (const v of ids) {
             const id = parseInt(v, 10);
             if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-            if (!document.getElementById(`${PH_PREFIX}${id}`)?.isConnected) continue;
+            if (!phEl(id)?.isConnected || !hasSinglePlaceholder(id)) continue;
             seen.add(id);
-            try { orig(id); } catch (_) {}
+            valid.push(id);
+          }
+          if (!valid.length) return;
+          try { orig(...valid); } catch (_) {
+            for (const id of valid) {
+              try { orig(id); } catch (_) {}
+            }
           }
         };
       } catch (_) {}
@@ -619,6 +757,7 @@
   async function runCore() {
     if (isBlocked()) return 0;
     patchShowAds();
+    sweepDeadWraps();
 
     const cfg = await fetchConfig();
     if (!cfg || cfg.excluded) return 0;
@@ -685,7 +824,7 @@
       S.burstCount++;
       scheduleRun(n => {
         if (!n && !S.pending.length) { S.burstActive = false; return; }
-        setTimeout(step, n > 0 ? 150 : 300);
+        setTimeout(step, n > 0 ? 80 : 180);
       });
     };
     step();
@@ -695,7 +834,7 @@
 
   function cleanup() {
     blockedUntil = ts() + 1500;
-    mutate(() => document.querySelectorAll(`.${WRAP_CLASS}`).forEach(dropWrap));
+    mutate(() => document.querySelectorAll(WRAP_SEL).forEach(dropWrap));
     S.cfg          = null;
     S.poolsReady   = false;
     S.pools        = { topics: [], posts: [], categories: [] };
@@ -703,26 +842,59 @@
     S.mountedIds.clear();
     S.lastShow.clear();
     S.wrapByKey.clear();
+    S.ezActiveIds.clear();
+    S.ezShownSinceDestroy.clear();
     S.inflight     = 0;
     S.pending      = [];
     S.pendingSet.clear();
+    if (S.showBatchTimer) { clearTimeout(S.showBatchTimer); S.showBatchTimer = 0; }
+    if (S.destroyBatchTimer) { clearTimeout(S.destroyBatchTimer); S.destroyBatchTimer = 0; }
+    S.destroyPending = [];
+    S.destroyPendingSet.clear();
     S.burstActive  = false;
     S.runQueued    = false;
+    S.sweepQueued   = false;
+    S.scrollSpeed  = 0;
+    S.lastScrollY  = 0;
+    S.lastScrollTs = 0;
+  }
+
+  function nodeMatchesAny(node, selectors) {
+    if (!(node instanceof Element)) return false;
+    for (const sel of selectors) {
+      try { if (node.matches(sel)) return true; } catch (_) {}
+    }
+    return false;
+  }
+
+  function nodeContainsAny(node, selectors) {
+    if (!(node instanceof Element)) return false;
+    for (const sel of selectors) {
+      try { if (node.querySelector(sel)) return true; } catch (_) {}
+    }
+    return false;
   }
 
   // ── 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) {
+        let sawWrapRemoval = false;
+        for (const n of m.removedNodes) {
+          if (n.nodeType !== 1) continue;
+          if (nodeMatchesAny(n, [WRAP_SEL]) || nodeContainsAny(n, [WRAP_SEL])) {
+            sawWrapRemoval = true;
+          }
+        }
+        if (sawWrapRemoval) queueSweepDeadWraps();
         for (const n of m.addedNodes) {
           if (n.nodeType !== 1) continue;
+          try { healFalseEmpty(n); } catch (_) {}
           // 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;} })) {
+          if (nodeMatchesAny(n, CONTENT_SEL_LIST) || nodeContainsAny(n, CONTENT_SEL_LIST)) {
             requestBurst(); return;
           }
         }
@@ -733,27 +905,6 @@
 
   // ── Utilitaires ────────────────────────────────────────────────────────────
 
-  function muteConsole() {
-    if (window.__nbbEzMuted) return;
-    window.__nbbEzMuted = true;
-    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;
-      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;
@@ -775,6 +926,7 @@
   function warmNetwork() {
     const head = document.head;
     if (!head) return;
+    const frag = document.createDocumentFragment();
     for (const [rel, href, cors] of [
       ['preconnect',   'https://g.ezoic.net',                    true ],
       ['preconnect',   'https://go.ezoic.net',                   true ],
@@ -789,8 +941,9 @@
       const l = document.createElement('link');
       l.rel = rel; l.href = href;
       if (cors) l.crossOrigin = 'anonymous';
-      head.appendChild(l);
+      frag.appendChild(l);
     }
+    head.appendChild(frag);
   }
 
   // ── Bindings ───────────────────────────────────────────────────────────────
@@ -804,8 +957,8 @@
     $(window).on('action:ajaxify.end.nbbEzoic', () => {
       S.pageKey    = pageKey();
       blockedUntil = 0;
-      muteConsole(); ensureTcfLocator(); warmNetwork();
-      patchShowAds(); getIO(); ensureDomObserver(); requestBurst();
+      ensureTcfLocator(); warmNetwork();
+      patchShowAds(); getIO(); ensureDomObserver(); sweepDeadWraps(); requestBurst();
     });
 
     const burstEvts = [
@@ -827,7 +980,22 @@
 
   function bindScroll() {
     let ticking = false;
+    try {
+      S.lastScrollY = window.scrollY || window.pageYOffset || 0;
+      S.lastScrollTs = ts();
+    } catch (_) {}
     window.addEventListener('scroll', () => {
+      try {
+        const y = window.scrollY || window.pageYOffset || 0;
+        const t = ts();
+        const dy = y - (S.lastScrollY || 0);
+        const dt = Math.max(1, t - (S.lastScrollTs || t));
+        if (Math.abs(dy) > 1) S.scrollDir = dy >= 0 ? 1 : -1;
+        const inst = Math.abs(dy) * 1000 / dt;
+        S.scrollSpeed = S.scrollSpeed ? (S.scrollSpeed * 0.7 + inst * 0.3) : inst;
+        S.lastScrollY = y;
+        S.lastScrollTs = t;
+      } catch (_) {}
       if (ticking) return;
       ticking = true;
       requestAnimationFrame(() => { ticking = false; requestBurst(); });
@@ -837,7 +1005,6 @@
   // ── Boot ───────────────────────────────────────────────────────────────────
 
   S.pageKey = pageKey();
-  muteConsole();
   ensureTcfLocator();
   warmNetwork();
   patchShowAds();

package/public/style.css

@@ -56,23 +56,17 @@
   top: auto !important;
 }
 
-/* ── État vide ────────────────────────────────────────────────────────────── */
-/*
-  Ajouté 20s après showAds si aucun fill détecté.
-  Collapse à 1px (pas 0) : reste observable par l'IO si le fill arrive tard.
-*/
-.nodebb-ezoic-wrap.is-empty {
-  display: block !important;
-  height: 1px !important;
-  min-height: 1px !important;
-  max-height: 1px !important;
-  margin: 0 !important;
-  padding: 0 !important;
-  overflow: hidden !important;
-}
-
 /* ── Ezoic global (hors de nos wraps) ────────────────────────────────────── */
 .ezoic-ad {
   margin: 0 !important;
   padding: 0 !important;
 }
+
+
+/* Filet anti faux-empty : si la pub est rendue, ne pas laisser le wrap replié */
+.nodebb-ezoic-wrap.is-empty:has(iframe, [data-google-container-id], [id^="google_ads_iframe_"]) {
+  height: auto !important;
+  min-height: 1px !important;
+  max-height: none !important;
+  overflow: visible !important;
+}