nodebb-plugin-ezoic-infinite 1.4.95 → 1.4.97

package/package.json

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

package/public/client.js

@@ -7,8 +7,17 @@
   categoryItem: 'li[component="categories/category"]',
   }, WRAP_CLASS = 'ezoic-ad';
   const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-', MAX_INSERTS_PER_RUN = 3;
+  // Ultra-fast: preload ads before they enter viewport (especially above-the-fold)
+  const PRELOAD_ROOT_MARGIN = '1200px 0px';
+  const ABOVE_FOLD_MULT = 1.5; // render immediately if within 1.5× viewport height
+  const FAST_START_MS = 2500;  // aggressive preload window after page load
+
+  
+  // FLAG GLOBAL: Bloquer Ezoic pendant navigation
+  let EZOIC_BLOCKED = false;
+  
+  // DEBUG: Vérifier que le plugin charge
 
-  // Nécessaire pour savoir si on doit appeler destroyPlaceholders avant recyclage.
   const sessionDefinedIds = new Set();
 
   const insertingIds = new Set(), state = {
@@ -33,7 +42,43 @@
 
   obs: null,
   activeTimeouts: new Set(),
-  lastScrollRun: 0, };
+  lastScrollRun: 0,
+  io: null,
+  fastStartUntil: 0,
+};
+
+
+  // Track currently inserted ad wrappers for recycling
+  const liveArr = [];
+
+
+  // Network warm-up: reduce latency to Ezoic/CDN on first above-the-fold render
+  const _warmLinksDone = new Set();
+  function warmUpNetwork() {
+    try {
+      const head = document.head || document.getElementsByTagName('head')[0];
+      if (!head) return;
+      const links = [
+        ['preconnect', 'https://g.ezoic.net', true],
+        ['dns-prefetch', 'https://g.ezoic.net', false],
+        ['preconnect', 'https://go.ezoic.net', true],
+        ['dns-prefetch', 'https://go.ezoic.net', false],
+        ['preconnect', 'https://www.ezoic.net', true],
+        ['dns-prefetch', 'https://www.ezoic.net', false],
+      ];
+      for (const [rel, href, cors] of links) {
+        const key = rel + '|' + href;
+        if (_warmLinksDone.has(key)) continue;
+        _warmLinksDone.add(key);
+        const link = document.createElement('link');
+        link.rel = rel;
+        link.href = href;
+        if (cors) link.crossOrigin = 'anonymous';
+        head.appendChild(link);
+      }
+    } catch (e) {}
+  }
+
 
   function normalizeBool(v) {
   return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
@@ -106,9 +151,7 @@
 
   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) => {
-  // Utiliser sessionDefinedIds (survit aux navigations) plutôt que state.definedIds
   try { return sessionDefinedIds.has(id); } catch (e) { return true; }
   });
   if (!filtered.length) return;
@@ -119,6 +162,11 @@
   window.ezstandalone.destroyPlaceholders(filtered);
   }
   } catch (e) {}
+
+  // Recyclage: libérer IDs après 100ms
+    setTimeout(() => {
+      filtered.forEach(id => sessionDefinedIds.delete(id));
+    }, 100);
   };
   try {
   window.ezstandalone = window.ezstandalone || {};
@@ -126,10 +174,63 @@
   if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') call();
   else window.ezstandalone.cmd.push(call);
   } catch (e) {}
+
+  // Recyclage: libérer IDs après 100ms
+  setTimeout(() => {
+  filtered.forEach(id => sessionDefinedIds.delete(id));
+  }, 100);
   }
 
+  // Nettoyer éléments Ezoic invisibles qui créent espace vertical
+  function cleanupInvisibleEzoicElements() {
+  try {
+  document.querySelectorAll('.ezoic-ad').forEach(wrapper => {
+  const ph = wrapper.querySelector('[id^="ezoic-pub-ad-placeholder-"]');
+  if (!ph) return;
   
-  // Nettoyer les wrappers vides (sans pub) pour éviter espaces verticaux
+  // ULTRA-AGRESSIF: Supprimer TOUT sauf placeholder
+  Array.from(wrapper.children).forEach(child => {
+  if (child === ph || child.contains(ph)) return;
+  if (child.id && child.id.startsWith('ezoic-pub-ad-placeholder-')) return;
+  child.remove();
+  });
+  
+  // Forcer wrapper collé
+  wrapper.style.height = 'auto';
+  wrapper.style.overflow = 'hidden';
+  wrapper.style.lineHeight = '0';
+  wrapper.style.fontSize = '0';
+  wrapper.style.margin = '0';
+  wrapper.style.padding = '0';
+  
+  // CRITIQUE: Forcer suppression margin sur TOUS les .ezoic-ad enfants
+  // Pour overrider les margin-top/bottom:15px !important d'Ezoic
+  wrapper.querySelectorAll('.ezoic-ad, span.ezoic-ad').forEach(ezSpan => {
+  ezSpan.style.setProperty('margin-top', '0', 'important');
+  ezSpan.style.setProperty('margin-bottom', '0', 'important');
+  ezSpan.style.setProperty('margin-left', '0', 'important');
+  ezSpan.style.setProperty('margin-right', '0', 'important');
+  });
+  
+  // Nettoyer aussi DANS le placeholder
+  if (ph) {
+  Array.from(ph.children).forEach(child => {
+  // Garder seulement iframe, ins, img
+  const tag = child.tagName;
+  if (tag !== 'IFRAME' && tag !== 'INS' && tag !== 'IMG' && tag !== 'DIV') {
+  child.remove();
+  }
+  });
+  }
+  });
+  } catch (e) {}
+  }
+  
+  // Lancer cleanup périodique toutes les 2s
+  setInterval(() => {
+  try { cleanupInvisibleEzoicElements(); } catch (e) {}
+  }, 2000);
+
   function cleanupEmptyWrappers() {
   try {
   document.querySelectorAll('.ezoic-ad').forEach(wrapper => {
@@ -137,11 +238,17 @@
   if (ph && ph.children.length === 0) {
   // Placeholder vide après 3s = pub non chargée
   setTimeout(() => {
-  if (ph.children.length === 0) {
-  wrapper.remove();
-  }
-  }, 3000);
-  }
+      try {
+        // Give Ezoic more time on slower connections, and don't remove if we recently requested an ad.
+        const phId = ph && ph.id;
+        const id = phId ? parseInt(phId.replace(PLACEHOLDER_PREFIX, ''), 10) : 0;
+        const last = (id && state.lastShowById && state.lastShowById.get(id)) || 0;
+        if (ph.children.length === 0 && (!last || Date.now() - last > 10000)) {
+          wrapper.remove();
+        }
+      } catch (e) {}
+    }, 8000);
+    }
   });
   } catch (e) {}
   }
@@ -217,10 +324,8 @@
   if (findWrap(kindClass, afterPos)) return null;
 
   // 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;
 
@@ -233,7 +338,6 @@
   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);
   }
   }
@@ -244,48 +348,57 @@
   }
 
   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) {}
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      const ez = window.ezstandalone;
+      if (window.__nodebbEzoicPatched) return;
+      if (typeof ez.showAds !== 'function') return;
+
+      window.__nodebbEzoicPatched = true;
+      const orig = ez.showAds;
+
+      // Ezoic's ez-standalone.js logs warnings when asked to render an ID
+      // that isn't present in the DOM anymore. In an infinite-scroll context
+      // we must filter and call per-id.
+      ez.showAds = function (...args) {
+        if (EZOIC_BLOCKED) return;
+
+        let ids = [];
+        if (args.length === 1 && Array.isArray(args[0])) {
+          ids = args[0];
+        } else {
+          ids = 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;
+
+          const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+          if (!ph || !ph.isConnected) continue;
+
+          seen.add(id);
+          try { orig.call(ez, id); } catch (e) {}
+        }
+      };
+    } 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) {}
-  }
+    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;
-  // 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) {}
@@ -301,19 +414,18 @@
   if (!ph) return;
   // Already filled?
   if (ph.childNodes && ph.childNodes.length > 0) {
-  markFilled(wrap);
-  state.definedIds && state.definedIds.add(id); sessionDefinedIds.add(id);
+  markFilled(wrap); // Afficher wrapper
+  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) {}
+  markFilled(wrap); // CRITIQUE: Afficher wrapper maintenant
+  try { 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) {}
   }
@@ -333,15 +445,12 @@
   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]);
@@ -356,84 +465,144 @@
   // Ajouter à la batch
   pendingShowAdsIds.add(id);
 
-  // Debounce: attendre 100ms pour collecter tous les IDs
   clearTimeout(batchShowAdsTimer);
   batchShowAdsTimer = setTimeout(() => {
+  // CRITIQUE: Vérifier que nous sommes toujours sur la même page
+  const currentPageKey = getPageKey();
+  if (state.pageKey && currentPageKey !== state.pageKey) {
+  pendingShowAdsIds.clear();
+  return; // Page a changé, annuler
+  }
+  
   if (pendingShowAdsIds.size === 0) return;
 
   const idsArray = Array.from(pendingShowAdsIds);
   pendingShowAdsIds.clear();
 
+  // CRITIQUE: Vérifier que placeholders existent encore
+  const validIds = idsArray.filter(id => {
+  const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+  return ph && ph.isConnected;
+  });
+  
+  if (validIds.length === 0) return;
+
   // Appeler showAds avec TOUS les IDs en une fois
   try {
+  // CRITIQUE: Re-patcher AVANT chaque appel pour être sûr
+  patchShowAds();
+  
   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);
+  window.ezstandalone.showAds(validIds);
   // Tracker tous les IDs
-  idsArray.forEach(id => {
+  validIds.forEach(id => {
   state.lastShowById.set(id, Date.now());
   sessionDefinedIds.add(id);
   });
   }
   });
   } catch (e) {}
+  
+  // CRITIQUE: Nettoyer éléments invisibles APRÈS que pubs soient chargées
+  setTimeout(() => {
+  cleanupInvisibleEzoicElements();
+  }, 1500); // 1.5s pour laisser Ezoic charger
   }, 100);
   }
 
-  function callShowAdsWhenReady(id) {
+  
+function callShowAdsWhenReady(id) {
   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;
+  if (now - last < 2500) return;
+
+  const phId = `${PLACEHOLDER_PREFIX}${id}`;
+
+  const tryShowOrQueue = () => {
+    if (EZOIC_BLOCKED) return false;
+    const el = document.getElementById(phId);
+    if (!el || !el.isConnected) return false;
+
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      const ez = window.ezstandalone;
+
+      if (typeof ez.showAds === 'function') {
+        state.lastShowById.set(id, Date.now());
+        ez.showAds(id);
+        sessionDefinedIds.add(id);
+        return true;
+      }
+
+      // Queue once to run as soon as Ezoic is ready
+      ez.cmd = ez.cmd || [];
+      if (!el.__ezoicQueued) {
+        el.__ezoicQueued = true;
+        ez.cmd.push(() => {
+          try {
+            if (EZOIC_BLOCKED) return;
+            const ph = document.getElementById(phId);
+            if (!ph || !ph.isConnected) return;
+            state.lastShowById.set(id, Date.now());
+            window.ezstandalone.showAds(id);
+            sessionDefinedIds.add(id);
+          } catch (e) {}
+        });
+      }
+    } 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);
-  }
+  (function waitForPh() {
+    if (state.pageKey !== startPageKey) return;
+
+    const el = document.getElementById(phId);
+    if (el && el.isConnected) {
+      // tag id for IO callback
+      try { el.setAttribute('data-ezoic-id', String(id)); } catch (e) {}
+
+      // If above-the-fold (or during the fast-start window), fire immediately.
+      const inFastWindow = state.fastStartUntil && Date.now() < state.fastStartUntil;
+      if (isAboveFold(el) || (inFastWindow && (el.getBoundingClientRect().top < window.innerHeight * 3))) {
+        if (tryShowOrQueue()) {
+          state.pendingById.delete(id);
+          return;
+        }
+      }
+
+      // Otherwise, preload via IntersectionObserver
+      if (!state.pendingById.has(id)) {
+        state.pendingById.add(id);
+        const io = ensurePreloadObserver();
+        try { io && io.observe(el); } catch (e) {}
+
+        // Safety fallback: if it still hasn't rendered after 6s, force attempt.
+        const t = setTimeout(() => {
+          tryShowOrQueue();
+          state.pendingById.delete(id);
+        }, 6000);
+        state.activeTimeouts.add(t);
+      }
+      return;
+    }
+
+    attempts += 1;
+    if (attempts < 100) {
+      const timeoutId = setTimeout(waitForPh, 25);
+      state.activeTimeouts.add(timeoutId);
+    }
   })();
-  }
+}
 
-  async function fetchConfig() {
+async function fetchConfig() {
   if (state.cfg) return state.cfg;
   if (state.cfgPromise) return state.cfgPromise;
 
@@ -484,7 +653,6 @@
   const el = items[afterPos - 1];
   if (!el || !el.isConnected) continue;
 
-  // Prevent adjacent ads (DOM-based, robust against virtualization)
   if (isAdjacentAd(el) || isPrevAd(el)) {
   continue;
   }
@@ -501,17 +669,14 @@
 
   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);
@@ -525,12 +690,10 @@
   }
 
   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);
@@ -547,7 +710,6 @@
   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) {
@@ -566,11 +728,45 @@
   }
 
   function cleanup() {
-  destroyUsedPlaceholders();
+  // DEBUG: Vérifier que cleanup est appelé
+  // CRITIQUE: BLOQUER Ezoic immédiatement
+  EZOIC_BLOCKED = true;
+  
+  // Détruire TOUS les placeholders Ezoic AVANT de supprimer DOM
+  const allWrappers = document.querySelectorAll('.ezoic-ad');
+  const allIds = [];
+  allWrappers.forEach(wrapper => {
+  const ph = wrapper.querySelector('[id^="ezoic-pub-ad-placeholder-"]');
+  if (ph) {
+  const match = ph.id.match(/\d+/);
+  if (match) allIds.push(parseInt(match[0]));
+  }
+  });
+  
+  // CRITIQUE: Vider COMPLÈTEMENT sessionDefinedIds
+  // Pour éviter que d'anciens IDs soient encore en mémoire
+  
+  // CRITIQUE: Détruire AUSSI tous les IDs tracés dans state
+  // Pour annuler les anciens IDs qu'Ezoic a en mémoire
+  const trackedIds = [
+  ...Array.from(state.usedTopics),
+  ...Array.from(state.usedPosts),
+  ...Array.from(state.usedCategories)
+  ];
+  
+  const allIdsToDestroy = [...new Set([...allIds, ...trackedIds, ...Array.from(sessionDefinedIds)])];
+  sessionDefinedIds.clear(); // ✅ VIDER TOUT
+  
+  if (allIdsToDestroy.length > 0) {
+  destroyPlaceholderIds(allIdsToDestroy);
+  }
+  
+  // Annuler batch showAds en attente
+  pendingShowAdsIds.clear();
+  clearTimeout(batchShowAdsTimer);
 
-  // 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 => {
+  // Maintenant supprimer DOM
+  allWrappers.forEach(el => {
   try { el.remove(); } catch (e) {}
   });
 
@@ -585,26 +781,18 @@
   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; }
+  if (state.io) { try { state.io.disconnect(); } catch (e) {} state.io = null; }
 
   state.scheduled = false;
   clearTimeout(state.timer);
@@ -617,8 +805,40 @@
   try { state.obs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
   }
 
+  function ensurePreloadObserver() {
+  if (state.io) return state.io;
+  try {
+  state.io = new IntersectionObserver((entries) => {
+    for (const ent of entries) {
+      if (!ent.isIntersecting) continue;
+      const el = ent.target;
+      try { state.io && state.io.unobserve(el); } catch (e) {}
+      const idAttr = el && el.getAttribute && el.getAttribute('data-ezoic-id');
+      const id = parseInt(idAttr, 10);
+      if (Number.isFinite(id) && id > 0) {
+        // Try immediately; otherwise it will queue via ezstandalone.cmd
+        try { callShowAdsWhenReady(id); } catch (e) {}
+      }
+    }
+  }, { root: null, rootMargin: PRELOAD_ROOT_MARGIN, threshold: 0.01 });
+  } catch (e) { state.io = null; }
+  return state.io;
+  }
+
+  function isAboveFold(el) {
+  try {
+    if (!el || !el.getBoundingClientRect) return false;
+    const r = el.getBoundingClientRect();
+    return r.top < (window.innerHeight * ABOVE_FOLD_MULT) && r.bottom > -200;
+  } catch (e) { return false; }
+  }
+
   async function runCore() {
-  // Attendre que canInsert soit true (protection race condition navigation)
+  // CRITIQUE: Ne rien insérer si navigation en cours
+  if (EZOIC_BLOCKED) {
+  return;
+  }
+  
   if (!state.canShowAds) {
   return;
   }
@@ -661,7 +881,6 @@
 
   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;
@@ -673,12 +892,9 @@
   }
 
   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);
@@ -708,19 +924,33 @@
 
   $(window).on('action:ajaxify.start.ezoicInfinite', () => cleanup());
 
-  $(window).on('action:ajaxify.end.ezoicInfinite', () => {
+    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
   state.pageKey = getPageKey();
+
+  // Débloquer Ezoic IMMÉDIATEMENT pour la nouvelle page
+  EZOIC_BLOCKED = false;
+
+  // Warm-up réseau + runtime Ezoic dès que possible
+  warmUpNetwork();
+  patchShowAds();
+
+  // Ultra-fast preload window
+  state.fastStartUntil = Date.now() + FAST_START_MS;
+
   ensureObserver();
+  ensurePreloadObserver();
 
-  // 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;
+
+  // HERO slot ASAP (above-the-fold)
+  insertHeroAdEarly();
+
+  // Relancer l'insertion normale
+  scheduleRun();
   });
 
   $(window).on('action:category.loaded.ezoicInfinite', () => {
   ensureObserver();
-  // category.loaded = infinite scroll, Ezoic déjà chargé normalement
   waitForContentThenRun();
   });
   $(window).on('action:topics.loaded.ezoicInfinite', () => {
@@ -750,7 +980,6 @@
   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;
@@ -760,7 +989,6 @@
   }, { passive: true });
   }
 
-  // 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;
@@ -791,7 +1019,6 @@
   })();
   }
 
-  // Fonction qui attend que Ezoic soit vraiment chargé
   function waitForEzoicThenRun() {
   let attempts = 0;
   const maxAttempts = 50; // 50 × 200ms = 10s max
@@ -820,8 +1047,16 @@
   bind();
   bindScroll();
   ensureObserver();
+  ensurePreloadObserver();
   state.pageKey = getPageKey();
 
+  // Warm-up réseau dès le boot
+  warmUpNetwork();
+  patchShowAds();
+  state.fastStartUntil = Date.now() + FAST_START_MS;
+  // HERO slot ASAP au premier chargement
+  insertHeroAdEarly();
+
   // Attendre que Ezoic soit chargé avant d'insérer
   waitForEzoicThenRun();
 })();

package/public/style.css

@@ -1,3 +1,19 @@
-.ezoic-ad{height:auto !important; padding:0 !important; margin: 0.25rem 0;}
-.ezoic-ad .ezoic-ad-inner{padding:0;margin:0;}
-.ezoic-ad .ezoic-ad-inner > div{padding:0;margin:0;}
+.ezoic-ad,
+.ezoic-ad *,
+span.ezoic-ad,
+span[class*="ezoic"] {
+  min-height: 0 !important;
+  min-width: 0 !important;
+}
+/* Reduce layout shifts and kill extra spacing around Ezoic wrappers */
+.ezoic-ad {
+  display: block;
+  width: 100%;
+  margin: 0 !important;
+  padding: 0 !important;
+  overflow: hidden;
+}
+.ezoic-ad > [id^="ezoic-pub-ad-placeholder-"] {
+  margin: 0 !important;
+  padding: 0 !important;
+}