nodebb-plugin-ezoic-infinite 1.8.6 → 1.8.7

package/package.json

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

package/public/client.js

@@ -77,18 +77,12 @@
   const A_CREATED   = 'data-ezoic-created';  // timestamp création ms
   const A_SHOWN     = 'data-ezoic-shown';    // timestamp dernier showAds ms
 
-  // Tunables (stables en prod)
+  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   = 10;      // plus réactif si NodeBB injecte en rafale
-  const MAX_INFLIGHT      = 4;       // max showAds() simultanés (garde-fou)
-  const MAX_SHOW_BATCH    = 4;       // ids max par appel showAds(...ids)
-  const SHOW_THROTTLE_MS  = 600;     // anti-spam showAds() par id (plus réactif)
-  const SHOW_RELEASE_MS   = 700;     // relâche inflight après showAds() batché
-  const SHOW_FAILSAFE_MS  = 7000;    // relâche forcée si stack pub lente
-  const BATCH_FLUSH_MS    = 40;      // 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 = 120;     // délai min entre deux déclenchements de burst
+  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';
@@ -132,23 +126,14 @@
     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,
     burstCount:   0,
     lastBurstTs:  0,
+    lastScrollY:  0,
+    scrollDir:    1,     // 1=down, -1=up
   };
 
   let blockedUntil = 0;
@@ -159,106 +144,10 @@
   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 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();
-    });
-  }
-
-  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 ─────────────────────────────────────────────────────────────────
 
@@ -413,25 +302,6 @@ function destroyBeforeReuse(ids) {
     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.
-    for (const [key, wrap] of Array.from(S.wrapByKey.entries())) {
-      if (wrap?.isConnected) continue;
-      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 (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) :
@@ -439,84 +309,83 @@ function destroyBeforeReuse(ids) {
    * 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;
-  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 (metric < bestPrefFilledMetric) { bestPrefFilledMetric = metric; bestPrefFilled = 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 targetRect = targetEl?.getBoundingClientRect?.() || { top: vh, bottom: vh };
+
+    // Recyclage bidirectionnel :
+    // - scroll vers le bas  -> recycle préférentiellement des wraps loin au-dessus
+    // - scroll vers le haut -> recycle préférentiellement des wraps loin en-dessous
+    // Fallback sur l'autre côté si aucun candidat.
+    const aboveThreshold = -vh;      // wrap entièrement/suffisamment au-dessus
+    const belowThreshold = vh * 2;   // wrap loin sous le viewport
+
+    let aboveEmpty = null, aboveEmptyBottom = Infinity;
+    let aboveFilled = null, aboveFilledBottom = Infinity;
+    let belowEmpty = null, belowEmptyTop = -Infinity;
+    let belowFilled = null, belowFilledTop = -Infinity;
+
+    document.querySelectorAll(`.${WRAP_CLASS}.${klass}`).forEach(wrap => {
+      try {
+        if (!wrap?.isConnected) return;
+        const rect = wrap.getBoundingClientRect();
+
+        if (rect.bottom < aboveThreshold) {
+          if (!isFilled(wrap)) {
+            if (rect.bottom < aboveEmptyBottom) { aboveEmptyBottom = rect.bottom; aboveEmpty = wrap; }
+          } else {
+            if (rect.bottom < aboveFilledBottom) { aboveFilledBottom = rect.bottom; aboveFilled = wrap; }
+          }
+          return;
         }
-      }
-      if (!filled) {
-        if (metric < bestAnyMetric) { bestAnyMetric = metric; bestAnyEmpty = wrap; }
-      } else {
-        if (metric < bestAnyFilledMetric) { bestAnyFilledMetric = metric; bestAnyFilled = wrap; }
-      }
-    } 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 (_) {}
+        if (rect.top > belowThreshold) {
+          if (!isFilled(wrap)) {
+            if (rect.top > belowEmptyTop) { belowEmptyTop = rect.top; belowEmpty = wrap; }
+          } else {
+            if (rect.top > belowFilledTop) { belowFilledTop = rect.top; belowFilled = wrap; }
+          }
+        }
+      } catch (_) {}
+    });
 
-  return { id, wrap: best };
-}
+    const preferBelow = (S.scrollDir < 0) || (targetRect.top < vh * 0.5);
+    const pickAbove = () => aboveEmpty ?? aboveFilled;
+    const pickBelow = () => belowEmpty ?? belowFilled;
+    const best = preferBelow ? (pickBelow() ?? pickAbove()) : (pickAbove() ?? pickBelow());
+    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 ────────────────────────────────────
 
@@ -552,7 +421,7 @@ function recycleAndMove(klass, targetEl, newKey) {
       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.ezActiveIds.delete(id); S.mountedIds.delete(id); }
+      if (Number.isFinite(id)) S.mountedIds.delete(id);
       const key = w.getAttribute(A_ANCHOR);
       if (key && S.wrapByKey.get(key) === w) S.wrapByKey.delete(key);
       w.remove();
@@ -627,8 +496,7 @@ function recycleAndMove(klass, targetEl, newKey) {
       const key = anchorKey(klass, el);
       if (findWrap(key)) continue;
 
-      let id = pickId(poolKey);
-      if (!id) { sweepDeadWraps(); id = pickId(poolKey); }
+      const id = pickId(poolKey);
       if (id) {
         const w = insertAfter(el, id, klass, key);
         if (w) { observePh(id); inserted++; }
@@ -659,107 +527,76 @@ function recycleAndMove(klass, targetEl, newKey) {
   }
 
   function observePh(id) {
-    const ph = phEl(id);
+    const ph = document.getElementById(`${PH_PREFIX}${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;
-  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);
+  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);
   }
-  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);
 
-  requestAnimationFrame(() => {
-    try {
-      if (isBlocked()) { clearTimeout(timer); return release(); }
+  function drainQueue() {
+    if (isBlocked()) return;
+    while (S.inflight < MAX_INFLIGHT && S.pending.length) {
+      const id = S.pending.shift();
+      S.pendingSet.delete(id);
+      startShow(id);
+    }
+  }
 
-      const valid = [];
-      const t = ts();
+  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);
 
-      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;
+    requestAnimationFrame(() => {
+      try {
+        if (isBlocked()) { clearTimeout(timer); return release(); }
+        const ph = document.getElementById(`${PH_PREFIX}${id}`);
+        if (!ph?.isConnected || isFilled(ph)) { clearTimeout(timer); return release(); }
 
+        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_CLASS}`)?.setAttribute(A_SHOWN, String(t)); } catch (_) {}
-        valid.push(id);
-      }
 
-      if (!valid.length) { clearTimeout(timer); return release(); }
+        try { ph.closest?.(`.${WRAP_CLASS}`)?.setAttribute(A_SHOWN, String(t)); } catch (_) {}
 
-      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(); }
-  });
-}
+        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);
+  }
 
   // ── Patch Ezoic showAds ────────────────────────────────────────────────────
   //
@@ -777,21 +614,14 @@ function startShowBatch(ids) {
         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 valid = [];
+          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);
             if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-            if (!phEl(id)?.isConnected || !hasSinglePlaceholder(id)) continue;
+            if (!document.getElementById(`${PH_PREFIX}${id}`)?.isConnected) continue;
             seen.add(id);
-            valid.push(id);
-          }
-          if (!valid.length) return;
-          try { orig(...valid); } catch (_) {
-            for (const id of valid) {
-              try { orig(id); } catch (_) {}
-            }
+            try { orig(id); } catch (_) {}
           }
         };
       } catch (_) {}
@@ -808,7 +638,6 @@ function startShowBatch(ids) {
   async function runCore() {
     if (isBlocked()) return 0;
     patchShowAds();
-    sweepDeadWraps();
 
     const cfg = await fetchConfig();
     if (!cfg || cfg.excluded) return 0;
@@ -875,7 +704,7 @@ function startShowBatch(ids) {
       S.burstCount++;
       scheduleRun(n => {
         if (!n && !S.pending.length) { S.burstActive = false; return; }
-        setTimeout(step, n > 0 ? 80 : 180);
+        setTimeout(step, n > 0 ? 150 : 300);
       });
     };
     step();
@@ -893,21 +722,11 @@ function startShowBatch(ids) {
     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;
   }
 
   // ── MutationObserver ───────────────────────────────────────────────────────
@@ -918,14 +737,6 @@ function startShowBatch(ids) {
     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 ((n.matches && n.matches(`.${WRAP_CLASS}`)) || (n.querySelector && n.querySelector(`.${WRAP_CLASS}`))) {
-            sawWrapRemoval = true;
-          }
-        }
-        if (sawWrapRemoval) queueSweepDeadWraps();
         for (const n of m.addedNodes) {
           if (n.nodeType !== 1) continue;
           // matches() d'abord (O(1)), querySelector() seulement si nécessaire
@@ -1013,7 +824,7 @@ function startShowBatch(ids) {
       S.pageKey    = pageKey();
       blockedUntil = 0;
       muteConsole(); ensureTcfLocator(); warmNetwork();
-      patchShowAds(); getIO(); ensureDomObserver(); sweepDeadWraps(); requestBurst();
+      patchShowAds(); getIO(); ensureDomObserver(); requestBurst();
     });
 
     const burstEvts = [
@@ -1035,21 +846,12 @@ function startShowBatch(ids) {
 
   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;
+        if (Math.abs(dy) > 2) S.scrollDir = dy > 0 ? 1 : -1;
         S.lastScrollY = y;
-        S.lastScrollTs = t;
       } catch (_) {}
       if (ticking) return;
       ticking = true;
@@ -1060,6 +862,7 @@ function startShowBatch(ids) {
   // ── Boot ───────────────────────────────────────────────────────────────────
 
   S.pageKey = pageKey();
+  try { S.lastScrollY = window.scrollY || window.pageYOffset || 0; } catch (_) { S.lastScrollY = 0; }
   muteConsole();
   ensureTcfLocator();
   warmNetwork();

package/public/style.css

@@ -56,6 +56,21 @@
   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;