nodebb-plugin-ezoic-infinite 1.4.90 → 1.4.92

package/public/public/client.js

@@ -1,776 +1,827 @@
 (function () {
   'use strict';
-
   const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
-
   const SELECTORS = {
-    topicItem: 'li[component="category/topic"]',
-    postItem: '[component="post"][data-pid]',
-    categoryItem: 'li[component="categories/category"]',
-  };
+  topicItem: 'li[component="category/topic"]',
+  postItem: '[component="post"][data-pid]',
+  categoryItem: 'li[component="categories/category"]',
+  }, WRAP_CLASS = 'ezoic-ad';
+  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-', MAX_INSERTS_PER_RUN = 3;
 
-  const WRAP_CLASS = 'ezoic-ad';
-  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
-
-  const MAX_INSERTS_PER_RUN = 2;
-
-  const state = {
-    pageKey: null,
-    cfg: null,
-    cfgPromise: null,
-
-    poolTopics: [],
-    poolPosts: [],
-    poolCategories: [],
-
-    usedTopics: new Set(),
-    usedPosts: new Set(),
-    usedCategories: new Set(),
-
-    // wrappers currently on page (FIFO for recycling)
-    liveBetween: [],
-    liveMessage: [],
-    liveCategory: [],
-    usedCategories: new Set(),
-
-    lastShowById: new Map(),
-    pendingById: new Set(),
-    retryById: new Map(),
-    retryTimer: null,
-    retryQueue: [],
-    retryQueueSet: new Set(),
-    retryQueueRunning: false,
-    badIds: new Set(),
-    definedIds: new Set(),
-
-    scheduled: false,
-    timer: null,
-
-    obs: null,
-    attempts: 0,
-  };
+  // Nécessaire pour savoir si on doit appeler destroyPlaceholders avant recyclage.
+  const sessionDefinedIds = new Set();
+
+  const insertingIds = new Set(), state = {
+  pageKey: null,
+  cfg: null,
+  cfgPromise: null,
+
+  poolTopics: [],
+  poolPosts: [],
+  poolCategories: [],
+
+  usedTopics: new Set(),
+  usedPosts: new Set(),
+  usedCategories: new Set(),
+
+  lastShowById: new Map(),
+  pendingById: new Set(),
+  definedIds: new Set(),
+
+  scheduled: false,
+  timer: null,
+
+  obs: null,
+  activeTimeouts: new Set(),
+  lastScrollRun: 0, };
 
   function normalizeBool(v) {
-    return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
+  return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
   function uniqInts(lines) {
-    const out = [];
-    const seen = new Set();
-    for (const v of lines) {
-      const n = parseInt(v, 10);
-      if (Number.isFinite(n) && n > 0 && !seen.has(n)) {
-        seen.add(n);
-        out.push(n);
-      }
-    }
-    return out;
+  const out = [], seen = new Set();
+  for (const v of lines) {
+  const n = parseInt(v, 10);
+  if (Number.isFinite(n) && n > 0 && !seen.has(n)) {
+  seen.add(n);
+  out.push(n);
+  }
+  }
+  return out;
   }
 
   function parsePool(raw) {
-    if (!raw) return [];
-    const lines = String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean);
-    return uniqInts(lines);
+  if (!raw) return [];
+  const lines = String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+  return uniqInts(lines);
   }
 
   function getPageKey() {
-    try {
-      const ax = window.ajaxify;
-      if (ax && ax.data) {
-        if (ax.data.tid) return `topic:${ax.data.tid}`;
-        if (ax.data.cid) return `cid:${ax.data.cid}:${window.location.pathname}`;
-      }
-    } catch (e) {}
-    return window.location.pathname;
+  try {
+  const ax = window.ajaxify;
+  if (ax && ax.data) {
+  if (ax.data.tid) return `topic:${ax.data.tid}`;
+  if (ax.data.cid) return `cid:${ax.data.cid}:${window.location.pathname}`;
+  }
+  } catch (e) {}
+  return window.location.pathname;
   }
 
   function getKind() {
-    const p = window.location.pathname || '';
-    if (/^\/topic\//.test(p)) return 'topic';
-    if (/^\/category\//.test(p)) return 'categoryTopics';
-    if (p === '/' || /^\/categories/.test(p)) return 'categories';
-    // fallback by DOM
-    if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
-    if (document.querySelector(SELECTORS.postItem)) return 'topic';
-    if (document.querySelector(SELECTORS.topicItem)) return 'categoryTopics';
-    return 'other';
+  const p = window.location.pathname || '';
+  if (/^\/topic\//.test(p)) return 'topic';
+  if (/^\/category\//.test(p)) return 'categoryTopics';
+  if (p === '/' || /^\/categories/.test(p)) return 'categories';
+  // fallback by DOM
+  if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
+  if (document.querySelector(SELECTORS.postItem)) return 'topic';
+  if (document.querySelector(SELECTORS.topicItem)) return 'categoryTopics';
+  return 'other';
   }
 
   function getTopicItems() {
-    return Array.from(document.querySelectorAll(SELECTORS.topicItem));
+  return Array.from(document.querySelectorAll(SELECTORS.topicItem));
   }
 
   function getCategoryItems() {
-    return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
+  return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
   }
 
   function getPostContainers() {
-    const nodes = Array.from(document.querySelectorAll(SELECTORS.postItem));
-    return nodes.filter((el) => {
-      if (!el || !el.isConnected) return false;
-      if (!el.querySelector('[component="post/content"]')) return false;
-      const parentPost = el.parentElement && el.parentElement.closest('[component="post"][data-pid]');
-      if (parentPost && parentPost !== el) return false;
-      if (el.getAttribute('component') === 'post/parent') return false;
-      return true;
-    });
+  const nodes = Array.from(document.querySelectorAll(SELECTORS.postItem));
+  return nodes.filter((el) => {
+  if (!el || !el.isConnected) return false;
+  if (!el.querySelector('[component="post/content"]')) return false;
+  const parentPost = el.parentElement && el.parentElement.closest('[component="post"][data-pid]');
+  if (parentPost && parentPost !== el) return false;
+  if (el.getAttribute('component') === 'post/parent') return false;
+  return true;
+  });
   }
 
-
   function safeRect(el) {
-    try { return el.getBoundingClientRect(); } catch (e) { return null; }
+  try { return el.getBoundingClientRect(); } catch (e) { return null; }
   }
 
   function destroyPlaceholderIds(ids) {
-    if (!ids || !ids.length) return;
-    // Only destroy ids that were actually "defined" (filled at least once) to avoid Ezoic warnings.
-    const filtered = ids.filter((id) => {
-      try { return state.definedIds && state.definedIds.has(id); } catch (e) { return true; }
-    });
-    if (!filtered.length) return;
-
-    const call = () => {
-      try {
-        if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
-          window.ezstandalone.destroyPlaceholders(filtered);
-        }
-      } catch (e) {}
-    };
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') call();
-      else window.ezstandalone.cmd.push(call);
-    } catch (e) {}
-  }
-    };
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') call();
-      else window.ezstandalone.cmd.push(call);
-    } catch (e) {}
+  if (!ids || !ids.length) return;
+  // Only destroy ids that were actually "defined" (filled at least once) to avoid Ezoic warnings.
+  const filtered = ids.filter((id) => {
+  // Utiliser sessionDefinedIds (survit aux navigations) plutôt que state.definedIds
+  try { return sessionDefinedIds.has(id); } catch (e) { return true; }
+  });
+  if (!filtered.length) return;
+
+  const call = () => {
+  try {
+  if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
+  window.ezstandalone.destroyPlaceholders(filtered);
+  }
+  } catch (e) {}
+  };
+  try {
+  window.ezstandalone = window.ezstandalone || {};
+  window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+  if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') call();
+  else window.ezstandalone.cmd.push(call);
+  } catch (e) {}
+  }
+
+  
+  // Nettoyer les wrappers vides (sans pub) pour éviter espaces verticaux
+  function cleanupEmptyWrappers() {
+  try {
+  document.querySelectorAll('.ezoic-ad').forEach(wrapper => {
+  const ph = wrapper.querySelector('[id^="ezoic-pub-ad-placeholder-"]');
+  if (ph && ph.children.length === 0) {
+  // Placeholder vide après 3s = pub non chargée
+  setTimeout(() => {
+  if (ph.children.length === 0) {
+  wrapper.remove();
+  }
+  }, 3000);
+  }
+  });
+  } catch (e) {}
   }
 
   function getRecyclable(liveArr) {
-    const margin = 1800;
-    for (let i = 0; i < liveArr.length; i++) {
-      const entry = liveArr[i];
-      if (!entry || !entry.wrap || !entry.wrap.isConnected) { liveArr.splice(i, 1); i--; continue; }
-      const r = safeRect(entry.wrap);
-      if (r && r.bottom < -margin) {
-        liveArr.splice(i, 1);
-        return entry;
-      }
-    }
-    return null;
-  }
-
-  function moveWrapAfter(wrap, target, kindClass, afterPos) {
-    try {
-      wrap.className = `${WRAP_CLASS} ${kindClass}`;
-      wrap.setAttribute('data-ezoic-after', String(afterPos));
-      target.insertAdjacentElement('afterend', wrap);
-      return true;
-    } catch (e) {
-      return false;
-    }
+  const margin = 600;
+  for (let i = 0; i < liveArr.length; i++) {
+  const entry = liveArr[i];
+  if (!entry || !entry.wrap || !entry.wrap.isConnected) { liveArr.splice(i, 1); i--; continue; }
+  const r = safeRect(entry.wrap);
+  if (r && r.bottom < -margin) {
+  liveArr.splice(i, 1);
+  return entry;
+  }
+  }
+  return null;
   }
 
   function pickId(pool, liveArr) {
-    if (pool.length) return { id: pool.shift(), recycled: null };
-    const recycled = getRecyclable(liveArr);
-    if (recycled) return { id: recycled.id, recycled };
-    return { id: null, recycled: null };
+  if (pool.length) return { id: pool.shift(), recycled: null };
+  const recycled = getRecyclable(liveArr);
+  if (recycled) return { id: recycled.id, recycled };
+  return { id: null, recycled: null };
   }
 
-
   function resetPlaceholderInWrap(wrap, id) {
-    try {
-      if (!wrap) return;
-      try { wrap.removeAttribute('data-ezoic-filled'); } catch (e) {}
-      try { if (wrap.__ezoicFillObs) { wrap.__ezoicFillObs.disconnect(); wrap.__ezoicFillObs = null; } } catch (e) {}
-      const old = wrap.querySelector && wrap.querySelector(`#${PLACEHOLDER_PREFIX}${id}`);
-      if (old) old.remove();
-      // Remove any leftover markup inside wrapper
-      wrap.querySelectorAll && wrap.querySelectorAll('iframe, ins').forEach(n => n.remove());
-      const ph = document.createElement('div');
-      ph.id = `${PLACEHOLDER_PREFIX}${id}`;
-      wrap.appendChild(ph);
-    } catch (e) {}
+  try {
+  if (!wrap) return;
+  try { wrap.removeAttribute('data-ezoic-filled'); } catch (e) {}
+  if (wrap.__ezoicFillObs) { wrap.__ezoicFillObs.disconnect(); wrap.__ezoicFillObs = null; }
+  const old = wrap.querySelector && wrap.querySelector(`#${PLACEHOLDER_PREFIX}${id}`);
+  if (old) old.remove();
+  // Remove any leftover markup inside wrapper
+  wrap.querySelectorAll && wrap.querySelectorAll('iframe, ins').forEach(n => n.remove());
+  const ph = document.createElement('div');
+  ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+  wrap.appendChild(ph);
+  } catch (e) {}
   }
 
   function isAdjacentAd(target) {
-    if (!target || !target.nextElementSibling) return false;
-    const next = target.nextElementSibling;
-    if (next && next.classList && next.classList.contains(WRAP_CLASS)) return true;
-    return false;
+  if (!target || !target.nextElementSibling) return false;
+  const next = target.nextElementSibling;
+  if (next && next.classList && next.classList.contains(WRAP_CLASS)) return true;
+  return false;
   }
 
   function isPrevAd(target) {
-    if (!target || !target.previousElementSibling) return false;
-    const prev = target.previousElementSibling;
-    if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) return true;
-    return false;
+  if (!target || !target.previousElementSibling) return false;
+  const prev = target.previousElementSibling;
+  if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) return true;
+  return false;
   }
 
   function buildWrap(id, kindClass, afterPos) {
-    const wrap = document.createElement('div');
-    wrap.className = `${WRAP_CLASS} ${kindClass}`;
-    wrap.setAttribute('data-ezoic-after', String(afterPos));
-    wrap.style.width = '100%';
+  const wrap = document.createElement('div');
+  wrap.className = `${WRAP_CLASS} ${kindClass}`;
+  wrap.setAttribute('data-ezoic-after', String(afterPos));
+  wrap.style.width = '100%';
 
-    const ph = document.createElement('div');
-    ph.id = `${PLACEHOLDER_PREFIX}${id}`;
-    wrap.appendChild(ph);
-    return wrap;
+  const ph = document.createElement('div');
+  ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+  wrap.appendChild(ph);
+  return wrap;
   }
 
   function findWrap(kindClass, afterPos) {
-    return document.querySelector(`.${WRAP_CLASS}.${kindClass}[data-ezoic-after="${afterPos}"]`);
+  return document.querySelector(`.${WRAP_CLASS}.${kindClass}[data-ezoic-after="${afterPos}"]`);
   }
 
   function insertAfter(target, id, kindClass, afterPos) {
-    if (!target || !target.insertAdjacentElement) return null;
-    if (findWrap(kindClass, afterPos)) return null;
-    const wrap = buildWrap(id, kindClass, afterPos);
-    target.insertAdjacentElement('afterend', wrap);
-    attachFillObserver(wrap, id);
-    return wrap;
-  }
+  if (!target || !target.insertAdjacentElement) return null;
+  if (findWrap(kindClass, afterPos)) return null;
 
-  function destroyUsedPlaceholders() {
-    const ids = [];
-    try {
-      state.usedTopics.forEach((id) => ids.push(id));
-      state.usedPosts.forEach((id) => ids.push(id));
-      state.usedCategories && state.usedCategories.forEach((id) => ids.push(id));
-    } catch (e) {}
-    destroyPlaceholderIds(ids);
-  }
-      } catch (e) {}
-    };
+  // CRITICAL: Double-lock pour éviter race conditions sur les doublons
+  // 1. Vérifier qu'aucun autre thread n'est en train d'insérer cet ID
+  if (insertingIds.has(id)) return null;
+
+  // 2. Vérifier qu'aucun placeholder avec cet ID n'existe déjà dans le DOM
+  const existingPh = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+  if (existingPh && existingPh.isConnected) return null;
 
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') call();
-      else window.ezstandalone.cmd.push(call);
-    } catch (e) {}
+  // Acquérir le lock
+  insertingIds.add(id);
+
+  try {
+  const wrap = buildWrap(id, kindClass, afterPos);
+  target.insertAdjacentElement('afterend', wrap);
+  attachFillObserver(wrap, id);
+  return wrap;
+  } finally {
+  // Libérer le lock après 100ms (le temps que le DOM soit stable)
+  setTimeout(() => insertingIds.delete(id), 50);
+  }
   }
 
-  function patchShowAds() {
-    // Minimal safety net: batch showAds can be triggered by other scripts; split into individual calls.
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      const ez = window.ezstandalone;
-      if (ez.__nodebbEzoicPatched) return;
-      if (typeof ez.showAds !== 'function') return;
-
-      ez.__nodebbEzoicPatched = true;
-      const orig = ez.showAds;
-
-      ez.showAds = function (arg) {
-        if (Array.isArray(arg)) {
-          const seen = new Set();
-          for (const v of arg) {
-            const id = parseInt(v, 10);
-            if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-            seen.add(id);
-            try { orig.call(ez, id); } catch (e) {}
-          }
-          return;
-        }
-        return orig.apply(ez, arguments);
-      };
-    } catch (e) {}
+  function destroyUsedPlaceholders() {
+  const ids = [...state.usedTopics, ...state.usedPosts, ...state.usedCategories];
+  if (ids.length) destroyPlaceholderIds(ids);
   }
 
+  function patchShowAds() {
+  // Minimal safety net: batch showAds can be triggered by other scripts; split into individual calls.
+  // Also ensures the patch is applied even if Ezoic loads after our script.
+  const applyPatch = () => {
+  try {
+  window.ezstandalone = window.ezstandalone || {}, ez = window.ezstandalone;
+  if (window.__nodebbEzoicPatched) return;
+  if (typeof ez.showAds !== 'function') return;
+
+  window.__nodebbEzoicPatched = true;
+  const orig = ez.showAds;
+
+  ez.showAds = function (arg) {
+  if (Array.isArray(arg)) {
+  const seen = new Set();
+  for (const v of arg) {
+  const id = parseInt(v, 10);
+  if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
+  seen.add(id);
+  try { orig.call(ez, id); } catch (e) {}
+  }
+  return;
+  }
+  return orig.apply(ez, arguments);
+  };
+  } catch (e) {}
+  };
 
+  applyPatch();
+  // Si Ezoic n'est pas encore chargé, appliquer le patch via sa cmd queue
+  if (!window.__nodebbEzoicPatched) {
+  try {
+  window.ezstandalone = window.ezstandalone || {};
+  window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+  window.ezstandalone.cmd.push(applyPatch);
+  } catch (e) {}
+  }
+  }
 
   function markFilled(wrap) {
-    try {
-      if (!wrap) return;
-      try { wrap.removeAttribute('data-ezoic-filled'); } catch (e) {}
-      try { if (wrap.__ezoicFillObs) { wrap.__ezoicFillObs.disconnect(); wrap.__ezoicFillObs = null; } } catch (e) {}
-      wrap.setAttribute('data-ezoic-filled', '1');
-    } catch (e) {}
+  try {
+  if (!wrap) return;
+  // Disconnect the fill observer first (no need to remove+re-add the attribute)
+  if (wrap.__ezoicFillObs) { wrap.__ezoicFillObs.disconnect(); wrap.__ezoicFillObs = null; }
+  wrap.setAttribute('data-ezoic-filled', '1');
+  } catch (e) {}
   }
 
   function isWrapMarkedFilled(wrap) {
-    try { return wrap && wrap.getAttribute && wrap.getAttribute('data-ezoic-filled') === '1'; } catch (e) { return false; }
+  try { return wrap && wrap.getAttribute && wrap.getAttribute('data-ezoic-filled') === '1'; } catch (e) { return false; }
   }
 
   function attachFillObserver(wrap, id) {
-    try {
-      const ph = wrap && wrap.querySelector && wrap.querySelector(`#${PLACEHOLDER_PREFIX}${id}`);
-      if (!ph) return;
-      // Already filled?
-      if (ph.childNodes && ph.childNodes.length > 0) {
-        markFilled(wrap);
-        state.definedIds && state.definedIds.add(id);
-        return;
-      }
-      const obs = new MutationObserver(() => {
-        if (ph.childNodes && ph.childNodes.length > 0) {
-          markFilled(wrap);
-          try { state.definedIds && state.definedIds.add(id); } catch (e) {}
-          try { obs.disconnect(); } catch (e) {}
-        }
-      });
-      obs.observe(ph, { childList: true, subtree: true });
-      // Keep a weak reference on the wrapper so we can disconnect on recycle/remove
-      wrap.__ezoicFillObs = obs;
-    } catch (e) {}
+  try {
+  const ph = wrap && wrap.querySelector && wrap.querySelector(`#${PLACEHOLDER_PREFIX}${id}`);
+  if (!ph) return;
+  // Already filled?
+  if (ph.childNodes && ph.childNodes.length > 0) {
+  markFilled(wrap);
+  state.definedIds && state.definedIds.add(id); sessionDefinedIds.add(id);
+  return;
+  }
+  const obs = new MutationObserver(() => {
+  if (ph.childNodes && ph.childNodes.length > 0) {
+  markFilled(wrap);
+  try { state.definedIds && state.definedIds.add(id); sessionDefinedIds.add(id); } catch (e) {}
+  try { obs.disconnect(); } catch (e) {}
+  }
+  });
+  obs.observe(ph, { childList: true, subtree: true });
+  // Keep a weak reference on the wrapper so we can disconnect on recycle/remove
+  wrap.__ezoicFillObs = obs;
+  } catch (e) {}
   }
 
   function isPlaceholderFilled(id) {
-    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-    if (!ph || !ph.isConnected) return false;
-
-    const wrap = ph.parentElement;
-    if (wrap && isWrapMarkedFilled(wrap)) return true;
-
-    const filled = !!(ph.childNodes && ph.childNodes.length > 0);
-    if (filled) {
-      try { state.definedIds && state.definedIds.add(id); } catch (e) {}
-      try { markFilled(wrap); } catch (e) {}
-    }
-    return filled;
-  }
-    return filled;
-  }
-
-  function scheduleRefill(delay = 350) {
-    clearTimeout(state.retryTimer);
-    state.retryTimer = setTimeout(refillUnfilled, delay);
-  }
-
-  function enqueueRetry(id) {
-    if (!id) return;
-    if (state.badIds && state.badIds.has(id)) return;
-    if (state.retryQueueSet.has(id)) return;
-    state.retryQueueSet.add(id);
-    state.retryQueue.push(id);
-    processRetryQueue();
-  }
-
-  function processRetryQueue() {
-    if (state.retryQueueRunning) return;
-    state.retryQueueRunning = true;
-
-    const step = () => {
-      const id = state.retryQueue.shift();
-      if (!id) {
-        state.retryQueueRunning = false;
-    state.badIds = new Set();
-    state.definedIds = new Set();
-        return;
-      }
-      state.retryQueueSet.delete(id);
-      // If this id was previously attempted and still empty, force a full reset before re-requesting.
-      const attempts = (state.retryById.get(id) || 0);
-      const phNow = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-      const wrapNow = phNow && phNow.parentElement;
-      // If Ezoic already defined this id earlier but the placeholder is empty now, we must destroy+reset before re-showAds.
-      if (wrapNow && wrapNow.isConnected && state.definedIds && state.definedIds.has(id) && !isPlaceholderFilled(id) && !isWrapMarkedFilled(wrapNow)) {
-        destroyPlaceholderIds([id]);
-        resetPlaceholderInWrap(wrapNow, id);
-      }
-      // If this id was previously attempted and still empty, force a full reset before re-requesting.
-      if (attempts > 0 && wrapNow && wrapNow.isConnected && !isPlaceholderFilled(id) && !isWrapMarkedFilled(wrapNow)) {
-        destroyPlaceholderIds([id]);
-        resetPlaceholderInWrap(wrapNow, id);
-      }
-      callShowAdsWhenReady(id);
-      setTimeout(step, 1100);
-    };
-
-    step();
-  }
-
-
-  function refillUnfilled() {
-    const wraps = Array.from(document.querySelectorAll(`.${WRAP_CLASS}`));
-    let scheduledAny = false;
-
-    for (const wrap of wraps) {
-      const ph = wrap.querySelector && wrap.querySelector(`[id^="${PLACEHOLDER_PREFIX}"]`);
-      if (!ph) continue;
-      const id = parseInt(ph.id.replace(PLACEHOLDER_PREFIX, ''), 10);
-      if (!Number.isFinite(id) || id <= 0) continue;
-
-      if (isPlaceholderFilled(id)) {
-        state.retryById.delete(id);
-        continue;
-      }
-      // If wrapper was marked filled, don't try to refill even if placeholder temporarily appears empty.
-      if (isWrapMarkedFilled(wrap)) {
-        state.retryById.delete(id);
-        continue;
-      }
-
-      const tries = (state.retryById.get(id) || 0);
-      if (tries >= 8) { state.badIds && state.badIds.add(id); continue; }
-
-      const r = safeRect(wrap);
-      if (r && (r.top > window.innerHeight + 1200 || r.bottom < -1200)) continue;
-
-      state.retryById.set(id, tries + 1);
-      enqueueRetry(id);
-      scheduledAny = true;
-    }
-
-    if (scheduledAny) scheduleRefill(700);
+  const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+  if (!ph || !ph.isConnected) return false;
+
+  const wrap = ph.parentElement;
+  if (wrap && isWrapMarkedFilled(wrap)) return true;
+
+  const filled = !!(ph.childNodes && ph.childNodes.length > 0);
+  if (filled) {
+  try { state.definedIds && state.definedIds.add(id); sessionDefinedIds.add(id); } catch (e) {}
+  try { markFilled(wrap); } catch (e) {}
+  }
+  return filled;
+  }
+
+  // Appeler showAds() en batch selon recommandations Ezoic
+  // Au lieu de showAds(id1), showAds(id2)... faire showAds(id1, id2, id3...)
+  let batchShowAdsTimer = null;
+  const pendingShowAdsIds = new Set();
+
+  function scheduleShowAdsBatch(id) {
+  if (!id) return;
+
+  // CRITIQUE: Si cet ID a déjà été défini (sessionDefinedIds), le détruire d'abord
+  if (sessionDefinedIds.has(id)) {
+  try {
+  destroyPlaceholderIds([id]);
+  sessionDefinedIds.delete(id);
+  } catch (e) {}
+  }
+
+  // Throttle: ne pas rappeler le même ID trop vite
+  const now = Date.now(), last = state.lastShowById.get(id) || 0;
+  if (now - last < 3500) return;
+
+  // Ajouter à la batch
+  pendingShowAdsIds.add(id);
+
+  // Debounce: attendre 100ms pour collecter tous les IDs
+  clearTimeout(batchShowAdsTimer);
+  batchShowAdsTimer = setTimeout(() => {
+  if (pendingShowAdsIds.size === 0) return;
+
+  const idsArray = Array.from(pendingShowAdsIds);
+  pendingShowAdsIds.clear();
+
+  // Appeler showAds avec TOUS les IDs en une fois
+  try {
+  window.ezstandalone = window.ezstandalone || {};
+  window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+  window.ezstandalone.cmd.push(function() {
+  if (typeof window.ezstandalone.showAds === 'function') {
+  // Appel batch: showAds(id1, id2, id3...)
+  window.ezstandalone.showAds(...idsArray);
+  // Tracker tous les IDs
+  idsArray.forEach(id => {
+  state.lastShowById.set(id, Date.now());
+  sessionDefinedIds.add(id);
+  });
+  }
+  });
+  } catch (e) {}
+  }, 100);
   }
 
   function callShowAdsWhenReady(id) {
-    if (!id) return;
-
-    const now = Date.now();
-    const last = state.lastShowById.get(id) || 0;
-    if (now - last < 3500) return;
-
-    const phId = `${PLACEHOLDER_PREFIX}${id}`;
-
-    const doCall = () => {
-      try {
-        window.ezstandalone = window.ezstandalone || {};
-        if (typeof window.ezstandalone.showAds === 'function') {
-          state.lastShowById.set(id, Date.now());
-          window.ezstandalone.showAds(id);
-          return true;
-        }
-      } catch (e) {}
-      return false;
-    };
-
-    let attempts = 0;
-    (function waitForPh() {
-      attempts += 1;
-      const el = document.getElementById(phId);
-      if (el && el.isConnected) {
-        if (doCall()) return;
-
-        if (state.pendingById.has(id)) return;
-        state.pendingById.add(id);
-
-        window.ezstandalone = window.ezstandalone || {};
-        window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-        window.ezstandalone.cmd.push(() => {
-          try {
-            if (typeof window.ezstandalone.showAds === 'function') {
-              state.pendingById.delete(id);
-              state.lastShowById.set(id, Date.now());
-              window.ezstandalone.showAds(id);
-            }
-          } catch (e) {}
-        });
-
-        let tries = 0;
-        (function tick() {
-          tries += 1;
-          if (doCall() || tries >= 5) {
-            if (tries >= 5) state.pendingById.delete(id);
-            return;
-          }
-          setTimeout(tick, 700);
-        })();
-        return;
-      }
-
-      if (attempts < 50) setTimeout(waitForPh, 50);
-    })();
-  }
-
-  function nextId(pool) {
-    // backward compatible: the injector passes the pool array
-    if (Array.isArray(pool) && pool.length) return pool.shift();
-    return null;
+  if (!id) return;
+
+  const now = Date.now(), last = state.lastShowById.get(id) || 0;
+  if (now - last < 3500) return;
+
+  const phId = `${PLACEHOLDER_PREFIX}${id}`, doCall = () => {
+  try {
+  window.ezstandalone = window.ezstandalone || {};
+  if (typeof window.ezstandalone.showAds === 'function') {
+
+  state.lastShowById.set(id, Date.now());
+  window.ezstandalone.showAds(id);
+  sessionDefinedIds.add(id);
+  return true;
+  }
+  } catch (e) {}
+  return false;
+  };
+
+  const startPageKey = state.pageKey;
+  let attempts = 0;
+  (function waitForPh() {
+  // Abort if the user navigated away since this showAds was scheduled
+  if (state.pageKey !== startPageKey) return;
+  // Abort if another concurrent call is already handling this id
+  if (state.pendingById.has(id)) return;
+
+  attempts += 1;
+  const el = document.getElementById(phId);
+  if (el && el.isConnected) {
+  // CRITIQUE: Vérifier que le placeholder est VISIBLE
+
+  // Si on arrive ici, soit visible, soit timeout
+
+  // Si doCall() réussit, Ezoic est chargé et showAds a été appelé → sortir
+  if (doCall()) {
+  state.pendingById.delete(id);
+  return;
+  }
+
+  }
+
+  if (attempts < 100) {
+  const timeoutId = setTimeout(waitForPh, 50);
+  state.activeTimeouts.add(timeoutId);
+  }
+  })();
   }
 
   async function fetchConfig() {
-    if (state.cfg) return state.cfg;
-    if (state.cfgPromise) return state.cfgPromise;
+  if (state.cfg) return state.cfg;
+  if (state.cfgPromise) return state.cfgPromise;
 
-    state.cfgPromise = (async () => {
-      try {
-        const res = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
-        if (!res.ok) return null;
-        state.cfg = await res.json();
-        return state.cfg;
-      } catch (e) {
-        return null;
-      } finally {
-        state.cfgPromise = null;
-      }
-    })();
+  state.cfgPromise = (async () => {
+  const MAX_TRIES = 3;
+  let delay = 800;
+  for (let attempt = 1; attempt <= MAX_TRIES; attempt++) {
+  try {
+  const res = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
+  if (res.ok) {
+  state.cfg = await res.json();
+  return state.cfg;
+  }
+  } catch (e) {}
+  if (attempt < MAX_TRIES) await new Promise(r => setTimeout(r, delay));
+  delay *= 2;
+  }
+  return null;
+  })();
 
-    return state.cfgPromise;
+  try { return await state.cfgPromise; } finally { state.cfgPromise = null; }
   }
 
   function initPools(cfg) {
-    if (state.poolTopics.length === 0) state.poolTopics = parsePool(cfg.placeholderIds);
-    if (state.poolPosts.length === 0) state.poolPosts = parsePool(cfg.messagePlaceholderIds);
-    if (state.poolCategories.length === 0) state.poolCategories = parsePool(cfg.categoryPlaceholderIds);
+  if (state.poolTopics.length === 0) state.poolTopics = parsePool(cfg.placeholderIds);
+  if (state.poolPosts.length === 0) state.poolPosts = parsePool(cfg.messagePlaceholderIds);
+  if (state.poolCategories.length === 0) state.poolCategories = parsePool(cfg.categoryPlaceholderIds);
   }
 
   function computeTargets(count, interval, showFirst) {
-    const out = [];
-    if (count <= 0) return out;
-    if (showFirst) out.push(1);
-    for (let i = 1; i <= count; i++) {
-      if (i % interval === 0) out.push(i);
-    }
-    return Array.from(new Set(out)).sort((a, b) => a - b);
+  const out = [];
+  if (count <= 0) return out;
+  if (showFirst) out.push(1);
+  for (let i = 1; i <= count; i++) {
+  if (i % interval === 0) out.push(i);
+  }
+  return Array.from(new Set(out)).sort((a, b) => a - b);
   }
 
   function injectBetween(kindClass, items, interval, showFirst, kindPool, usedSet) {
-    if (!items.length) return 0;
-    const targets = computeTargets(items.length, interval, showFirst);
-
-    let inserted = 0;
-    for (const afterPos of targets) {
-      if (inserted >= MAX_INSERTS_PER_RUN) break;
-
-      const el = items[afterPos - 1];
-      if (!el || !el.isConnected) continue;
-
-      // Prevent adjacent ads (DOM-based, robust against virtualization)
-      if (isAdjacentAd(el) || isPrevAd(el)) {
-        continue;
-      }
-
-      // Prevent back-to-back at load
-      const prevWrap = findWrap(kindClass, afterPos - 1);
-      if (prevWrap) continue;
-
-      if (findWrap(kindClass, afterPos)) continue;
-
-      const liveArr = (kindClass === 'ezoic-ad-between') ? state.liveBetween
-        : (kindClass === 'ezoic-ad-message') ? state.liveMessage
-        : state.liveCategory;
-
-      const pick = pickId(kindPool, liveArr);
-      const id = pick.id;
-      if (!id) break;
-
-      let wrap = null;
-      if (pick.recycled && pick.recycled.wrap) {
-        // Only destroy if Ezoic has actually defined this placeholder before
-        if (state.definedIds && state.definedIds.has(id)) {
-          destroyPlaceholderIds([id]);
-        }
-        // Remove the old wrapper entirely, then create a fresh wrapper at the new position (same id)
-        const oldWrap = pick.recycled.wrap;
-        try { if (oldWrap && oldWrap.__ezoicFillObs) { oldWrap.__ezoicFillObs.disconnect(); } } catch (e) {}
-        try { oldWrap && oldWrap.remove(); } catch (e) {}
-        wrap = insertAfter(el, id, kindClass, afterPos);
-        if (!wrap) continue;
-        setTimeout(() => { enqueueRetry(id); }, 450);
-      } else {
-        usedSet.add(id);
-        wrap = insertAfter(el, id, kindClass, afterPos);
-        if (!wrap) continue;
-      }
-
-      liveArr.push({ id, wrap });
-      // If adjacency ended up happening (e.g. DOM shifts), rollback this placement.
-      if (wrap && (wrap.previousElementSibling && wrap.previousElementSibling.classList && wrap.previousElementSibling.classList.contains(WRAP_CLASS)) || (wrap.nextElementSibling && wrap.nextElementSibling.classList && wrap.nextElementSibling.classList.contains(WRAP_CLASS))) {
-        try { wrap.remove(); } catch (e) {}
-        // Put id back if it was newly consumed (not recycled)
-        if (!(pick.recycled && pick.recycled.wrap)) {
-          try { kindPool.unshift(id); } catch (e) {}
-          try { usedSet.delete(id); } catch (e) {}
-        }
-        inserted -= 0; // no-op
-        continue;
-      }
-      if (!(pick.recycled && pick.recycled.wrap)) {
-        callShowAdsWhenReady(id);
-      }
-      inserted += 1;
-    }
-    return inserted;
+  if (!items.length) return 0;
+  const targets = computeTargets(items.length, interval, showFirst);
+
+  let inserted = 0;
+  for (const afterPos of targets) {
+  if (inserted >= MAX_INSERTS_PER_RUN) break;
+
+  const el = items[afterPos - 1];
+  if (!el || !el.isConnected) continue;
+
+  // Prevent adjacent ads (DOM-based, robust against virtualization)
+  if (isAdjacentAd(el) || isPrevAd(el)) {
+  continue;
+  }
+
+  // Prevent back-to-back at load
+  const prevWrap = findWrap(kindClass, afterPos - 1);
+  if (prevWrap) continue;
+
+  if (findWrap(kindClass, afterPos)) continue;
+
+  const pick = pickId(kindPool, []);
+  const id = pick.id;
+  if (!id) break;
+
+  let wrap = null;
+  if (pick.recycled && pick.recycled.wrap) {
+  // Only destroy if Ezoic has actually defined this placeholder before
+  if (sessionDefinedIds.has(id)) {
+  destroyPlaceholderIds([id]);
+  }
+  // Remove the old wrapper entirely, then create a fresh wrapper at the new position (same id)
+  const oldWrap = pick.recycled.wrap;
+  try { if (oldWrap && oldWrap.__ezoicFillObs) { oldWrap.__ezoicFillObs.disconnect(); } } catch (e) {}
+  try { oldWrap && oldWrap.remove(); } catch (e) {}
+  wrap = insertAfter(el, id, kindClass, afterPos);
+  if (!wrap) continue;
+  // Attendre que le wrapper soit dans le DOM puis appeler showAds
+  setTimeout(() => {
+  callShowAdsWhenReady(id);
+  }, 50);
+  } else {
+  usedSet.add(id);
+  wrap = insertAfter(el, id, kindClass, afterPos);
+  if (!wrap) continue;
+  // Micro-délai pour laisser le DOM se synchroniser
+  // Appel immédiat au lieu de 10ms delay
+  callShowAdsWhenReady(id);
+  }
+
+  liveArr.push({ id, wrap });
+  // If adjacency ended up happening (e.g. DOM shifts), rollback this placement.
+  if (wrap && (
+  (wrap.previousElementSibling && wrap.previousElementSibling.classList && wrap.previousElementSibling.classList.contains(WRAP_CLASS)) || (wrap.nextElementSibling && wrap.nextElementSibling.classList && wrap.nextElementSibling.classList.contains(WRAP_CLASS))
+  )) {
+  try { wrap.remove(); } catch (e) {}
+  // Put id back if it was newly consumed (not recycled)
+  if (!(pick.recycled && pick.recycled.wrap)) {
+  try { kindPool.unshift(id); } catch (e) {}
+  usedSet.delete(id);
+  }
+  continue;
+  }
+  inserted += 1;
+  }
+  return inserted;
   }
 
   function enforceNoAdjacentAds() {
-    const ads = Array.from(document.querySelectorAll(`.${WRAP_CLASS}`));
-    for (let i = 0; i < ads.length; i++) {
-      const ad = ads[i];
-      const prev = ad.previousElementSibling;
-      if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) ad.style.display = 'none';
-      else ad.style.display = '';
-    }
+  const ads = Array.from(document.querySelectorAll(`.${WRAP_CLASS}`));
+  for (let i = 0; i < ads.length; i++) {
+  const ad = ads[i], prev = ad.previousElementSibling;
+  if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) {
+  // Supprimer le wrapper adjacent au lieu de le cacher
+  try {
+  const ph = ad.querySelector && ad.querySelector(`[id^="${PLACEHOLDER_PREFIX}"]`);
+  if (ph) {
+  const id = parseInt(ph.id.replace(PLACEHOLDER_PREFIX, ''), 10);
+  if (Number.isFinite(id) && id > 0) {
+  // Détruire le placeholder si Ezoic l'a déjà défini
+  if (sessionDefinedIds.has(id)) {
+  destroyPlaceholderIds([id]);
+  }
+  }
+  }
+  ad.remove();
+  } catch (e) {}
+  }
+  }
   }
 
   function cleanup() {
-    destroyUsedPlaceholders();
+  destroyUsedPlaceholders();
+
+  // CRITIQUE: Supprimer TOUS les wrappers .ezoic-ad du DOM
+  // Sinon ils restent et deviennent "unused" sur la nouvelle page
+  document.querySelectorAll('.ezoic-ad').forEach(el => {
+  try { el.remove(); } catch (e) {}
+  });
+
+  state.pageKey = getPageKey();
+  state.cfg = null;
+  state.cfgPromise = null;
+
+  state.poolTopics = [];
+  state.poolPosts = [];
+  state.poolCategories = [];
+  state.usedTopics.clear();
+  state.usedPosts.clear();
+  state.usedCategories.clear();
+  state.lastShowById.clear();
+  // CRITIQUE: Vider pendingById pour annuler tous les showAds en cours
+  // Sinon Ezoic essaie d'accéder aux placeholders pendant que NodeBB vide le DOM
+  state.pendingById.clear();
+  state.definedIds.clear();
+
+  // NE PAS supprimer les wrappers Ezoic ici - ils seront supprimés naturellement
+  // quand NodeBB vide le DOM lors de la navigation ajaxify
+  // Les supprimer manuellement cause des problèmes avec l'état interne d'Ezoic
+
+  // CRITIQUE: Annuler TOUS les timeouts en cours pour éviter que les anciens
+  // showAds() continuent à s'exécuter après la navigation
+  state.activeTimeouts.forEach(id => {
+  try { clearTimeout(id); } catch (e) {}
+  });
+  state.activeTimeouts.clear();
+
+  // Vider aussi pendingById pour annuler les showAds en attente
+  state.pendingById.clear();
+
+  if (state.obs) { state.obs.disconnect(); state.obs = null; }
+
+  state.scheduled = false;
+  clearTimeout(state.timer);
+  state.timer = null;
+  }
+
+  function ensureObserver() {
+  if (state.obs) return;
+  state.obs = new MutationObserver(() => scheduleRun('mutation'));
+  try { state.obs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
+  }
 
-    state.pageKey = getPageKey();
-    state.cfg = null;
-    state.cfgPromise = null;
+  async function runCore() {
+  // Attendre que canInsert soit true (protection race condition navigation)
+  if (!state.canShowAds) {
+  return;
+  }
 
-    state.poolTopics = [];
-    state.poolPosts = [];
-    state.poolCategories = [];
-    state.poolCategories = [];
-    state.usedTopics.clear();
-    state.usedPosts.clear();
-    state.usedCategories && state.usedCategories.clear();
-    state.liveBetween = [];
-    state.liveMessage = [];
-    state.liveCategory = [];
-    state.usedCategories.clear();
+  patchShowAds();
 
-    state.lastShowById = new Map();
-    state.pendingById = new Set();
+  const cfg = await fetchConfig();
+  if (!cfg || cfg.excluded) return;
 
-    state.attempts = 0;
+  initPools(cfg);
 
-    document.querySelectorAll(`.${WRAP_CLASS}`).forEach(el => el.remove());
+  const kind = getKind();
+  let inserted = 0;
 
-    if (state.obs) { try { state.obs.disconnect(); } catch (e) {} state.obs = null; }
-    state.scheduled = false;
-    clearTimeout(state.timer);
-    state.timer = null;
+  if (kind === 'topic') {
+  if (normalizeBool(cfg.enableMessageAds)) {
+  inserted = injectBetween('ezoic-ad-message', getPostContainers(),
+  Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
+  normalizeBool(cfg.showFirstMessageAd),
+  state.poolPosts,
+  state.usedPosts);
+  }
+  } else if (kind === 'categoryTopics') {
+  if (normalizeBool(cfg.enableBetweenAds)) {
+  inserted = injectBetween('ezoic-ad-between', getTopicItems(),
+  Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
+  normalizeBool(cfg.showFirstTopicAd),
+  state.poolTopics,
+  state.usedTopics);
+  }
+  } else if (kind === 'categories') {
+  if (normalizeBool(cfg.enableCategoryAds)) {
+  inserted = injectBetween('ezoic-ad-categories', getCategoryItems(),
+  Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
+  normalizeBool(cfg.showFirstCategoryAd),
+  state.poolCategories,
+  state.usedCategories);
+  }
   }
 
-  function ensureObserver() {
-    if (state.obs) return;
-    state.obs = new MutationObserver(() => scheduleRun('mutation'));
-    try { state.obs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
-    setTimeout(() => { if (state.obs) { try { state.obs.disconnect(); } catch (e) {} state.obs = null; } }, 15000);
+  enforceNoAdjacentAds();
+
+  // If nothing inserted and list isn't in DOM yet (first click), retry a bit
+  let count = 0;
+  if (kind === 'topic') count = getPostContainers().length;
+  else if (kind === 'categoryTopics') count = getTopicItems().length;
+  else if (kind === 'categories') count = getCategoryItems().length;
+
+  if (count === 0 && 0 < 25) {
+  setTimeout(arguments[0], 50);
+  return;
   }
 
-  async function runCore() {
-    patchShowAds();
-
-    const cfg = await fetchConfig();
-    if (!cfg || cfg.excluded) return;
-
-    initPools(cfg);
-
-    const kind = getKind();
-    let inserted = 0;
-
-    if (kind === 'topic') {
-      if (normalizeBool(cfg.enableMessageAds)) {
-        inserted = injectBetween('ezoic-ad-message', getPostContainers(),
-          Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
-          normalizeBool(cfg.showFirstMessageAd),
-          'message',
-          state.usedPosts);
-      }
-    } else if (kind === 'categoryTopics') {
-      if (normalizeBool(cfg.enableBetweenAds)) {
-        inserted = injectBetween('ezoic-ad-between', getTopicItems(),
-          Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
-          normalizeBool(cfg.showFirstTopicAd),
-          'between',
-          state.usedTopics);
-      }
-    } else if (kind === 'categories') {
-      if (normalizeBool(cfg.enableCategoryAds)) {
-        inserted = injectBetween('ezoic-ad-categories', getCategoryItems(),
-          Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
-          normalizeBool(cfg.showFirstCategoryAd),
-          'categories',
-          state.usedCategories);
-      }
-    }
-
-    enforceNoAdjacentAds();
-    scheduleRefill(250);
-
-    // If nothing inserted and list isn't in DOM yet (first click), retry a bit
-    let count = 0;
-    if (kind === 'topic') count = getPostContainers().length;
-    else if (kind === 'categoryTopics') count = getTopicItems().length;
-    else if (kind === 'categories') count = getCategoryItems().length;
-
-    if (count === 0 && state.attempts < 25) {
-      state.attempts += 1;
-      setTimeout(() => scheduleRun('await-items'), 120);
-      return;
-    }
-
-    if (inserted >= MAX_INSERTS_PER_RUN) setTimeout(() => scheduleRun('continue'), 140);
+  if (inserted >= MAX_INSERTS_PER_RUN) {
+  // Plus d'insertions possibles ce cycle, continuer immédiatement
+  setTimeout(arguments[0], 50);
+  } else if (inserted === 0 && count > 0) {
+  // Pool épuisé ou recyclage pas encore disponible.
+  // Réessayer jusqu'à 8 fois (toutes les 400ms) pour laisser aux anciens wrappers
+  // le temps de défiler hors écran et devenir recyclables.
+  if (state.poolWaitAttempts < 8) {
+  state.poolWaitAttempts += 1;
+  setTimeout(arguments[0], 50);
+  } else {
+  }
+  } else if (inserted > 0) {
+  }
   }
 
   function scheduleRun() {
-    if (state.scheduled) return;
-    state.scheduled = true;
+  if (state.scheduled) return;
+  state.scheduled = true;
 
-    clearTimeout(state.timer);
-    state.timer = setTimeout(() => {
-      state.scheduled = false;
-      const pk = getPageKey();
-      if (state.pageKey && pk !== state.pageKey) return;
-      runCore().catch(() => {});
-    }, 80);
+  clearTimeout(state.timer);
+  state.timer = setTimeout(() => {
+  state.scheduled = false;
+  const pk = getPageKey();
+  if (state.pageKey && pk !== state.pageKey) return;
+  runCore().catch(() => {});
+  }, 50);
   }
 
   function bind() {
-    if (!$) return;
+  if (!$) return;
+
+  $(window).off('.ezoicInfinite');
+
+  $(window).on('action:ajaxify.start.ezoicInfinite', () => cleanup());
 
-    $(window).off('.ezoicInfinite');
+  $(window).on('action:ajaxify.end.ezoicInfinite', () => {
+  state.pageKey = getPageKey();
+  ensureObserver();
+
+  // CRITIQUE: Attendre 300ms avant de permettre l'insertion de nouveaux placeholders
+  // pour laisser les anciens showAds() (en cours) se terminer ou échouer proprement
+  // Sinon race condition: NodeBB vide le DOM pendant que Ezoic essaie d'accéder aux placeholders
+  state.canShowAds = true;
+  });
+
+  $(window).on('action:category.loaded.ezoicInfinite', () => {
+  ensureObserver();
+  // category.loaded = infinite scroll, Ezoic déjà chargé normalement
+  waitForContentThenRun();
+  });
+  $(window).on('action:topics.loaded.ezoicInfinite', () => {
+  ensureObserver();
+  waitForContentThenRun();
+  });
+
+  $(window).on('action:topic.loaded.ezoicInfinite', () => {
+  ensureObserver();
+  waitForContentThenRun();
+  });
+
+  $(window).on('action:posts.loaded.ezoicInfinite', () => {
+  ensureObserver();
+  // posts.loaded = infinite scroll
+  waitForContentThenRun();
+  });
+  }
+
+  function bindScroll() {
+  if (state.lastScrollRun > 0) return;
+  state.lastScrollRun = Date.now();
+  let ticking = false;
+  window.addEventListener('scroll', () => {
+  if (ticking) return;
+  ticking = true;
+  window.requestAnimationFrame(() => {
+  ticking = false;
+  enforceNoAdjacentAds();
+  // Debounce scheduleRun - une fois toutes les 2 secondes max au scroll
+  const now = Date.now();
+  if (!state.lastScrollRun || now - state.lastScrollRun > 2000) {
+  state.lastScrollRun = now;
+  scheduleRun();
+  }
+  });
+  }, { passive: true });
+  }
 
-    $(window).on('action:ajaxify.start.ezoicInfinite', () => cleanup());
+  // Fonction qui attend que la page ait assez de contenu avant d'insérer les pubs
+  function waitForContentThenRun() {
+  const MIN_WORDS = 250;
+  let attempts = 0;
+  const maxAttempts = 20; // 20 × 200ms = 4s max
 
-    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
-      state.pageKey = getPageKey();
-      ensureObserver();
-      scheduleRun();
-      setTimeout(scheduleRun, 200);
-      setTimeout(scheduleRun, 700);
-    });
+  (function check() {
+  attempts++;
 
-    $(window).on('action:category.loaded.ezoicInfinite', () => {
-      ensureObserver();
-      scheduleRun();
-      setTimeout(scheduleRun, 250);
-    });
+  // Compter les mots sur la page
+  const text = document.body.innerText || '';
+  const wordCount = text.split(/\s+/).filter(Boolean).length;
 
-    $(window).on('action:topics.loaded.ezoicInfinite', () => {
-      ensureObserver();
-      scheduleRun();
-      setTimeout(scheduleRun, 150);
-    });
+  if (wordCount >= MIN_WORDS) {
+  // Assez de contenu → lancer l'insertion
+  scheduleRun();
+  return;
+  }
 
-    $(window).on('action:topic.loaded.ezoicInfinite', () => {
-      ensureObserver();
-      scheduleRun();
-      setTimeout(scheduleRun, 200);
-    });
+  // Pas assez de contenu
+  if (attempts >= maxAttempts) {
+  // Timeout après 4s → tenter quand même
+  scheduleRun();
+  return;
+  }
 
-    $(window).on('action:posts.loaded.ezoicInfinite', () => {
-      ensureObserver();
-      scheduleRun();
-      setTimeout(scheduleRun, 150);
-    });
+  // Réessayer dans 200ms
+  setTimeout(check, 50);
+  })();
+  }
+
+  // Fonction qui attend que Ezoic soit vraiment chargé
+  function waitForEzoicThenRun() {
+  let attempts = 0;
+  const maxAttempts = 50; // 50 × 200ms = 10s max
+
+  (function check() {
+  attempts++;
+  // Vérifier si Ezoic est chargé
+  if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') {
+  // Ezoic est prêt → lancer l'insertion
+  scheduleRun();
+  waitForContentThenRun();
+  return;
+  }
+  // Ezoic pas encore prêt
+  if (attempts >= maxAttempts) {
+  // Tenter quand même
+  scheduleRun();
+  return;
+  }
+  // Réessayer dans 200ms
+  setTimeout(check, 50);
+  })();
   }
 
   cleanup();
   bind();
+  bindScroll();
   ensureObserver();
   state.pageKey = getPageKey();
-  scheduleRun();
-  setTimeout(scheduleRun, 250);
-})()
-  function bindScroll() {
-    if (state.__scrollBound) return;
-    state.__scrollBound = true;
-    let ticking = false;
-    window.addEventListener('scroll', () => {
-      if (ticking) return;
-      ticking = true;
-      window.requestAnimationFrame(() => {
-        ticking = false;
-        enforceNoAdjacentAds();
-        scheduleRefill(200);
-      });
-    }, { passive: true });
-  }
-
-;
+
+  // Attendre que Ezoic soit chargé avant d'insérer
+  waitForEzoicThenRun();
+})();