nodebb-plugin-ezoic-infinite 1.5.48 → 1.5.50

package/library.js

@@ -27,13 +27,21 @@ async function getAllGroups() {
   }
   const filtered = names.filter(name => !groups.isPrivilegeGroup(name));
   const data = await groups.getGroupsData(filtered);
-  // Sort alphabetically for ACP usability
-  data.sort((a, b) => String(a.name).localeCompare(String(b.name), 'fr', { sensitivity: 'base' }));
-  return data;
+  // Filter out nulls (groups deleted between the sorted-set read and getGroupsData)
+  const valid = data.filter(g => g && g.name);
+  valid.sort((a, b) => String(a.name).localeCompare(String(b.name), undefined, { sensitivity: 'base' }));
+  return valid;
 }
+let _settingsCache = null;
+let _settingsCacheAt = 0;
+const SETTINGS_TTL = 30000; // 30s
+
 async function getSettings() {
+  const now = Date.now();
+  if (_settingsCache && (now - _settingsCacheAt) < SETTINGS_TTL) return _settingsCache;
   const s = await meta.settings.get(SETTINGS_KEY);
-  return {
+  _settingsCacheAt = Date.now();
+  _settingsCache = {
     // Between-post ads (simple blocks) in category topic list
     enableBetweenAds: parseBool(s.enableBetweenAds, true),
     showFirstTopicAd: parseBool(s.showFirstTopicAd, false),
@@ -54,6 +62,7 @@ async function getSettings() {
 
     excludedGroups: normalizeExcludedGroups(s.excludedGroups),
   };
+  return _settingsCache;
 }
 
 async function isUserExcluded(uid, excludedGroups) {
@@ -62,6 +71,13 @@ async function isUserExcluded(uid, excludedGroups) {
   return (userGroups[0] || []).some(g => excludedGroups.includes(g.name));
 }
 
+plugin.onSettingsSet = function (data) {
+  // Invalider le cache dès que les settings de ce plugin sont sauvegardés via l'ACP
+  if (data && data.hash === SETTINGS_KEY) {
+    _settingsCache = null;
+  }
+};
+
 plugin.addAdminNavigation = async (header) => {
   header.plugins = header.plugins || [];
   header.plugins.push({
@@ -89,7 +105,7 @@ plugin.init = async ({ router, middleware }) => {
   router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, render);
   router.get('/api/admin/plugins/ezoic-infinite', render);
 
-  router.get('/api/plugins/ezoic-infinite/config', middleware.buildHeader, async (req, res) => {
+  router.get('/api/plugins/ezoic-infinite/config', async (req, res) => {
     const settings = await getSettings();
     const excluded = await isUserExcluded(req.uid, settings.excludedGroups);
 

package/package.json

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

package/plugin.json

@@ -11,6 +11,10 @@
     {
       "hook": "filter:admin.header.build",
       "method": "addAdminNavigation"
+    },
+    {
+      "hook": "action:settings.set",
+      "method": "onSettingsSet"
     }
   ],
   "staticDirs": {

package/public/admin.js

@@ -13,11 +13,10 @@
         e.preventDefault();
 
         Settings.save('ezoic-infinite', $form, function () {
-          // Toast vert (NodeBB core)
           if (alerts && typeof alerts.success === 'function') {
-            alerts.success('Enregistré');
+            alerts.success('[[admin/settings:saved]]');
           } else if (window.app && typeof window.app.alertSuccess === 'function') {
-            window.app.alertSuccess('Enregistré');
+            window.app.alertSuccess('[[admin/settings:saved]]');
           }
         });
       });

package/public/client.js

@@ -1,43 +1,177 @@
 (function () {
   'use strict';
 
+  // NodeBB client context
   const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
 
+  const WRAP_CLASS = 'ezoic-ad';
+  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
+
+  // Insert at most N ads per run to keep the UI smooth on infinite scroll
+  const MAX_INSERTS_PER_RUN = 3;
+
+  // Preload before viewport (earlier load for smoother scroll)
+  const PRELOAD_MARGIN_DESKTOP = '2600px 0px 2600px 0px';
+  const PRELOAD_MARGIN_MOBILE = '1500px 0px 1500px 0px';
+
+  // When the user scrolls very fast, temporarily preload more aggressively.
+  // This helps ensure ads are already in-flight before the user reaches them.
+  const PRELOAD_MARGIN_DESKTOP_BOOST = '4200px 0px 4200px 0px';
+  const PRELOAD_MARGIN_MOBILE_BOOST = '2500px 0px 2500px 0px';
+  const BOOST_DURATION_MS = 2500;
+  const BOOST_SPEED_PX_PER_MS = 2.2; // ~2200px/s
+
+  const MAX_INFLIGHT_DESKTOP = 4;
+  const MAX_INFLIGHT_MOBILE = 3;
+
+  function isBoosted() {
+    try { return Date.now() < (state.scrollBoostUntil || 0); } catch (e) { return false; }
+  }
+
+  function isMobile() {
+    try { return window && window.innerWidth && window.innerWidth < 768; } catch (e) { return false; }
+  }
+
+  function getPreloadRootMargin() {
+    if (isMobile()) return isBoosted() ? PRELOAD_MARGIN_MOBILE_BOOST : PRELOAD_MARGIN_MOBILE;
+    return isBoosted() ? PRELOAD_MARGIN_DESKTOP_BOOST : PRELOAD_MARGIN_DESKTOP;
+  }
+
+  function getMaxInflight() {
+    const base = isMobile() ? MAX_INFLIGHT_MOBILE : MAX_INFLIGHT_DESKTOP;
+    return base + (isBoosted() ? 1 : 0);
+  }
+
   const SELECTORS = {
     topicItem: 'li[component="category/topic"]',
     postItem: '[component="post"][data-pid]',
     categoryItem: 'li[component="categories/category"]',
   };
 
-  const WRAP_CLASS = 'ezoic-ad';
-  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
-  const MAX_INSERTS_PER_RUN = 3;
+  // Soft block during navigation / heavy DOM churn to avoid “placeholder does not exist” spam
+  let blockedUntil = 0;
+  function isBlocked() {
+    return Date.now() < blockedUntil;
+  }
 
   const state = {
     pageKey: null,
     cfg: null,
-    cfgPromise: null,
-    poolTopics: [],
-    poolPosts: [],
-    poolCategories: [],
-    usedTopics: new Set(),
-    usedPosts: new Set(),
-    usedCategories: new Set(),
+
+    // Full lists (never consumed) + cursors for round-robin reuse
+    allTopics: [],
+    allPosts: [],
+    allCategories: [],
+    curTopics: 0,
+    curPosts: 0,
+    curCategories: 0,
+
+    // throttle per placeholder id
     lastShowById: new Map(),
-    canShowAds: false,
-    scheduled: false,
-    timer: null,
-    obs: null,
+    internalDomChange: 0,
+    lastRecycleAt: { topic: 0, categoryTopics: 0, categories: 0 },
+
+    // track placeholders that have been shown at least once in this pageview
+    usedOnce: new Set(),
+
+    // observers / schedulers
+    domObs: null,
+    io: null,
+    runQueued: false,
+
+    // preloading budget
+    inflight: 0,
+    pending: [],
+    pendingSet: new Set(),
+
+    // fast scroll boosting
+    scrollBoostUntil: 0,
+    lastScrollY: 0,
+    lastScrollTs: 0,
+    ioMargin: null,
+
+    // hero)
+    heroDoneForPage: false,
   };
 
-  const sessionDefinedIds = new Set();
+  const insertingIds = new Set();
+
+  // ---------- lightweight "fade-in" for ad iframes ----------
+  // This reduces the perception of "flashing" when a slot appears empty then fills.
+  // We avoid scroll listeners and only react to DOM insertions.
+  const _faded = new WeakSet();
+  function _fadeInIframe(iframe) {
+    try {
+      if (!iframe || _faded.has(iframe)) return;
+      _faded.add(iframe);
+      iframe.style.opacity = '0';
+      iframe.style.transition = 'opacity 140ms ease';
+      // Next frame: show
+      requestAnimationFrame(() => {
+        try { iframe.style.opacity = '1'; } catch (e) {}
+      });
+    } catch (e) {}
+  }
+
+  const _adFillObserver = new MutationObserver((muts) => {
+    try {
+      for (const m of muts) {
+        if (m.addedNodes && m.addedNodes.length) {
+          for (const n of m.addedNodes) {
+            if (!n || n.nodeType !== 1) continue;
+            if (n.tagName === 'IFRAME') {
+              const w = n.closest && n.closest(`.${WRAP_CLASS}`);
+              if (w) _fadeInIframe(n);
+              continue;
+            }
+            // If a subtree is added, look for iframes inside ad wrappers only.
+            const ifs = n.querySelectorAll ? n.querySelectorAll(`.${WRAP_CLASS} iframe`) : null;
+            if (ifs && ifs.length) ifs.forEach(_fadeInIframe);
+          }
+        }
+      }
+    } catch (e) {}
+  });
+
+  try {
+    _adFillObserver.observe(document.documentElement, { subtree: true, childList: true });
+  } catch (e) {}
+
+
+
+  function markEmptyWrapper(id) {
+    try {
+      const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+      if (!ph || !ph.isConnected) return;
+      const wrap = ph.closest ? ph.closest(`.${WRAP_CLASS}`) : null;
+      if (!wrap) return;
+      // If still empty after a delay, collapse it.
+      setTimeout(() => {
+        try {
+          const ph2 = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+          if (!ph2 || !ph2.isConnected) return;
+          const w2 = ph2.closest ? ph2.closest(`.${WRAP_CLASS}`) : null;
+          if (!w2) return;
+          // consider empty if only whitespace and no iframes/ins/img
+          const hasAd = !!(ph2.querySelector && ph2.querySelector('iframe, ins, img, .ez-ad, .ezoic-ad'));
+          if (!hasAd) w2.classList.add('is-empty');
+        } catch (e) {}
+      }, 3500);
+    } catch (e) {}
+  }
+
+  // Production build: debug disabled
+  function dbg() {}
+
+  // ---------- small utils ----------
 
   function normalizeBool(v) {
     return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
   function uniqInts(lines) {
-    const out = [], seen = new Set();
+    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)) {
@@ -50,7 +184,10 @@
 
   function parsePool(raw) {
     if (!raw) return [];
-    const lines = String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+    const lines = String(raw)
+      .split(/\r?\n/)
+      .map(s => s.trim())
+      .filter(Boolean);
     return uniqInts(lines);
   }
 
@@ -70,6 +207,11 @@
     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';
   }
 
@@ -77,76 +219,234 @@
     return Array.from(document.querySelectorAll(SELECTORS.topicItem));
   }
 
+  function getCategoryItems() {
+    return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
+  }
+
   function getPostContainers() {
-    return Array.from(document.querySelectorAll(SELECTORS.postItem));
+    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 getCategoryItems() {
-    return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
+  // ---------- warm-up & patching ----------
+
+  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],
+
+        // Google ad stack (helps Safeframe/GPT warm up)
+        ['preconnect', 'https://pagead2.googlesyndication.com', true],
+        ['dns-prefetch', 'https://pagead2.googlesyndication.com', false],
+        ['preconnect', 'https://securepubads.g.doubleclick.net', true],
+        ['dns-prefetch', 'https://securepubads.g.doubleclick.net', false],
+        ['preconnect', 'https://tpc.googlesyndication.com', true],
+        ['dns-prefetch', 'https://tpc.googlesyndication.com', false],
+        ['preconnect', 'https://googleads.g.doubleclick.net', true],
+        ['dns-prefetch', 'https://googleads.g.doubleclick.net', false],
+        ['preconnect', 'https://static.doubleclick.net', true],
+        ['dns-prefetch', 'https://static.doubleclick.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) {}
   }
 
-  async function fetchConfig() {
-    if (state.cfg) return state.cfg;
-    if (state.cfgPromise) return state.cfgPromise;
+  // Patch showAds to avoid warnings when a placeholder disappears (infinite scroll, ajaxify)
+  function patchShowAds() {
+    const applyPatch = () => {
+      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;
+
+        ez.showAds = function (...args) {
+          if (isBlocked()) 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) {}
+    };
 
-    state.cfgPromise = (async () => {
+    applyPatch();
+    if (!window.__nodebbEzoicPatched) {
       try {
-        const res = await fetch('/api/ezoic-infinite/config');
-        if (!res.ok) return null;
-        const cfg = await res.json();
-        state.cfg = cfg;
-        return cfg;
-      } catch (e) {
-        return null;
-      }
-    })();
+        window.ezstandalone = window.ezstandalone || {};
+        window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+        window.ezstandalone.cmd.push(applyPatch);
+      } catch (e) {}
+    }
+  }
 
-    return state.cfgPromise;
+    const RECYCLE_COOLDOWN_MS = 1500;
+
+    function kindKeyFromClass(kindClass) {
+    if (kindClass === 'ezoic-ad-message') return 'topic';
+    if (kindClass === 'ezoic-ad-between') return 'categoryTopics';
+    if (kindClass === 'ezoic-ad-categories') return 'categories';
+    return 'topic';
+  }
+
+function withInternalDomChange(fn) {
+    state.internalDomChange++;
+    try { fn(); } finally { state.internalDomChange--; }
+  }
+
+  function canRecycle(kind) {
+    const now = Date.now();
+    const last = state.lastRecycleAt[kind] || 0;
+    if (now - last < RECYCLE_COOLDOWN_MS) return false;
+    state.lastRecycleAt[kind] = now;
+    return true;
+  }
+// ---------- config & pools ----------
+
+  async function fetchConfigOnce() {
+    if (state.cfg) return state.cfg;
+    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;
+    }
   }
 
   function initPools(cfg) {
-    if (!state.poolTopics.length) state.poolTopics = parsePool(cfg.poolTopics);
-    if (!state.poolPosts.length) state.poolPosts = parsePool(cfg.poolPosts);
-    if (!state.poolCategories.length) state.poolCategories = parsePool(cfg.poolCategories);
+    if (!cfg) return;
+    if (state.allTopics.length === 0) state.allTopics = parsePool(cfg.placeholderIds);
+    if (state.allPosts.length === 0) state.allPosts = parsePool(cfg.messagePlaceholderIds);
+    if (state.allCategories.length === 0) state.allCategories = parsePool(cfg.categoryPlaceholderIds);
   }
 
-  function destroyPlaceholderIds(ids) {
-    if (!ids || !ids.length) return;
-    const filtered = ids.filter(id => Number.isFinite(id) && id > 0);
-    if (!filtered.length) return;
+  // ---------- insertion primitives ----------
+
+  function isAdjacentAd(target) {
+    if (!target) return false;
+    const next = target.nextElementSibling;
+    if (next && next.classList && next.classList.contains(WRAP_CLASS)) return true;
+    const prev = target.previousElementSibling;
+    if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) return true;
+    return false;
+  }
 
+  
+  function getWrapIdFromWrap(wrap) {
     try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      
-      const call = () => {
-        if (typeof window.ezstandalone.destroyPlaceholders === 'function') {
-          window.ezstandalone.destroyPlaceholders(filtered);
-        }
-      };
+      const v = wrap.getAttribute('data-ezoic-wrapid');
+      if (v) return String(v);
+      const ph = wrap.querySelector(`[id^="${PLACEHOLDER_PREFIX}"]`);
+      if (ph && ph.id) return ph.id.replace(PLACEHOLDER_PREFIX, '');
+    } catch (e) {}
+    return null;
+  }
 
-      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
-        call();
-      } else {
-        window.ezstandalone.cmd.push(call);
+  function safeDestroyById(id) {
+    try {
+      const ez = window.ezstandalone;
+      if (ez && typeof ez.destroyPlaceholders === 'function') {
+        ez.destroyPlaceholders([`${PLACEHOLDER_PREFIX}${id}`]);
       }
-
-      // Recyclage: libérer après 100ms
-      setTimeout(() => {
-        filtered.forEach(id => sessionDefinedIds.delete(id));
-      }, 100);
     } catch (e) {}
   }
 
-  function buildWrap(id, kindClass, afterPos) {
+  function pruneOrphanWraps(kindClass, items) {
+    if (!items || !items.length) return 0;
+    const itemSet = new Set(items);
+    const wraps = document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`);
+    let removed = 0;
+
+    wraps.forEach((wrap) => {
+      // NodeBB can insert separators/spacers; accept an anchor within a few previous siblings
+      let ok = false;
+      let prev = wrap.previousElementSibling;
+      for (let i = 0; i < 3 && prev; i++) {
+        if (itemSet.has(prev)) { ok = true; break; }
+        prev = prev.previousElementSibling;
+      }
+
+      if (!ok) {
+        const id = getWrapIdFromWrap(wrap);
+        withInternalDomChange(() => {
+          try {
+            if (id) safeDestroyById(id);
+            wrap.remove();
+          } catch (e) {}
+        });
+        removed++;
+      }
+    });
+
+    if (removed) dbg('prune-orphan', kindClass, { removed });
+    return removed;
+  }
+
+  function refreshEmptyState(id) {
+    // After Ezoic has had a moment to fill the placeholder, toggle the CSS class.
+    window.setTimeout(() => {
+      try {
+        const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+        if (!ph || !ph.isConnected) return;
+        const wrap = ph.closest(`.${WRAP_CLASS}`);
+        if (!wrap) return;
+        const hasContent = ph.childElementCount > 0 || ph.offsetHeight > 0;
+        if (hasContent) wrap.classList.remove('is-empty');
+        else wrap.classList.add('is-empty');
+      } catch (e) {}
+    }, 3500);
+  }
+
+function buildWrap(id, kindClass, afterPos) {
     const wrap = document.createElement('div');
     wrap.className = `${WRAP_CLASS} ${kindClass}`;
     wrap.setAttribute('data-ezoic-after', String(afterPos));
+    wrap.setAttribute('data-ezoic-wrapid', String(id));
+    wrap.setAttribute('data-ezoic-ts', String(Date.now()));
     wrap.style.width = '100%';
 
     const ph = document.createElement('div');
     ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+    ph.setAttribute('data-ezoic-id', String(id));
     wrap.appendChild(ph);
+
     return wrap;
   }
 
@@ -157,215 +457,514 @@
   function insertAfter(target, id, kindClass, afterPos) {
     if (!target || !target.insertAdjacentElement) return null;
     if (findWrap(kindClass, afterPos)) return null;
+    if (insertingIds.has(id)) return null;
+
+    const existingPh = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+    if (existingPh && existingPh.isConnected) return null;
 
+    insertingIds.add(id);
     try {
       const wrap = buildWrap(id, kindClass, afterPos);
       target.insertAdjacentElement('afterend', wrap);
       return wrap;
+    } finally {
+      insertingIds.delete(id);
+    }
+  }
+
+  function pickIdFromAll(allIds, cursorKey) {
+    const n = allIds.length;
+    if (!n) return null;
+
+    // Try at most n ids to find one that's not already in the DOM
+    for (let tries = 0; tries < n; tries++) {
+      const idx = state[cursorKey] % n;
+      state[cursorKey] = (state[cursorKey] + 1) % n;
+
+      const id = allIds[idx];
+      const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+      if (ph && ph.isConnected) continue;
+
+      return id;
+    }
+    return null;
+  }
+
+
+  function removeOneOldWrap(kindClass) {
+    try {
+      const wraps = Array.from(document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`));
+      if (!wraps.length) return false;
+
+      const now = Date.now();
+
+      // Only recycle wraps that are clearly out of view AND old enough.
+      // This avoids the "unstable" feeling where ads disappear when the user scrolls back a bit.
+      const MIN_AGE_MS = 20000;      // 20s
+      const OFFSCREEN_PX = -5000;    // far above viewport
+
+      let victim = null;
+      for (const w of wraps) {
+        const r = w.getBoundingClientRect();
+        const ts = parseInt(w.getAttribute('data-ezoic-ts') || '0', 10);
+        const ageOk = !ts || (now - ts) >= MIN_AGE_MS;
+        if (ageOk && r.bottom < OFFSCREEN_PX) { victim = w; break; }
+      }
+
+      // If nothing is eligible, do not recycle. We'll simply skip inserting new ads this run.
+      if (!victim) return false;
+
+      // Unobserve placeholder if still observed
+      try {
+        const ph = victim.querySelector && victim.querySelector(`[id^="${PLACEHOLDER_PREFIX}"]`);
+        if (ph && state.io) state.io.unobserve(ph);
+      } catch (e) {}
+
+      victim.remove();
+      return true;
     } catch (e) {
-      return null;
+      return false;
     }
   }
 
-  function pickId(pool) {
-    if (!pool || !pool.length) return null;
-    return pool.shift();
+  function enqueueShow(id) {
+  if (!id || isBlocked()) return;
+
+  // Basic per-id throttle (prevents rapid re-requests when DOM churns)
+  const now = Date.now();
+  const last = state.lastShowById.get(id) || 0;
+  if (now - last < 900) return;
+
+  const max = getMaxInflight();
+  if (state.inflight >= max) {
+    if (!state.pendingSet.has(id)) {
+      state.pending.push(id);
+      state.pendingSet.add(id);
+    }
+    return;
   }
+  startShow(id);
+}
+
+function drainQueue() {
+  if (isBlocked()) return;
+  const max = getMaxInflight();
+  while (state.inflight < max && state.pending.length) {
+    const id = state.pending.shift();
+    state.pendingSet.delete(id);
+    startShow(id);
+  }
+}
+
+function startShow(id) {
+  if (!id || isBlocked()) return;
+
+  state.inflight++;
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    state.inflight = Math.max(0, state.inflight - 1);
+    drainQueue();
+  };
 
-  function callShowAds(id) {
-    if (!id) return;
-    
+  const hardTimer = setTimeout(release, 6500);
+
+  requestAnimationFrame(() => {
     try {
+      if (isBlocked()) return;
+
+      const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+      if (!ph || !ph.isConnected) return;
+
+      const now2 = Date.now();
+      const last2 = state.lastShowById.get(id) || 0;
+      if (now2 - last2 < 900) return;
+      state.lastShowById.set(id, now2);
+
       window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      
-      window.ezstandalone.cmd.push(function() {
-        if (typeof window.ezstandalone.showAds === 'function') {
-          window.ezstandalone.showAds(id);
-          sessionDefinedIds.add(id);
+      const ez = window.ezstandalone;
+
+      const doShow = () => {
+        try {
+          if (state.usedOnce && state.usedOnce.has(id) && typeof ez.destroyPlaceholders === 'function') {
+            try { ez.destroyPlaceholders(id); } catch (e) {}
+          }
+        } catch (e) {}
+
+        try { ez.showAds(id); } catch (e) {}
+        try { state.usedOnce && state.usedOnce.add(id); } catch (e) {}
+        try { markEmptyWrapper(id); } catch (e) {}
+
+        setTimeout(() => { clearTimeout(hardTimer); release(); }, 650);
+      };
+
+      if (Array.isArray(ez.cmd)) {
+        try { ez.cmd.push(doShow); } catch (e) { doShow(); }
+      } else {
+        doShow();
+      }
+    } finally {
+      // If we returned early, hardTimer will release.
+    }
+  });
+}
+
+
+  // ---------- preload / above-the-fold ----------
+
+  function ensurePreloadObserver() {
+    const desiredMargin = getPreloadRootMargin();
+    if (state.io && state.ioMargin === desiredMargin) return state.io;
+
+    // Rebuild IO if margin changed (e.g., scroll boost toggled)
+    if (state.io) {
+      try { state.io.disconnect(); } catch (e) {}
+      state.io = null;
+    }
+    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) enqueueShow(id);
         }
-      });
+      }, { root: null, rootMargin: desiredMargin, threshold: 0 });
+      state.ioMargin = desiredMargin;
+    } catch (e) {
+      state.io = null;
+      state.ioMargin = null;
+    }
+
+    // If we rebuilt the observer, re-observe existing placeholders so we don't miss them.
+    try {
+      if (state.io) {
+        const nodes = document.querySelectorAll(`[id^="${PLACEHOLDER_PREFIX}"]`);
+        nodes.forEach((n) => { try { state.io.observe(n); } catch (e) {} });
+      }
     } catch (e) {}
+    return state.io;
   }
 
-  function injectBetween(kindClass, items, interval, showFirst, pool, usedSet) {
-    if (!items || items.length === 0) return 0;
+  function observePlaceholder(id) {
+    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+    if (!ph || !ph.isConnected) return;
+    const io = ensurePreloadObserver();
+    try { io && io.observe(ph); } catch (e) {}
 
-    let inserted = 0;
-    const targets = [];
+    // If already above fold, fire immediately
+    try {
+      const r = ph.getBoundingClientRect();
+      const screens = isBoosted() ? 5.0 : 3.0;
+      const minBottom = isBoosted() ? -1500 : -800;
+      if (r.top < window.innerHeight * screens && r.bottom > minBottom) enqueueShow(id);
+    } catch (e) {}
+  }
 
-    for (let i = 0; i < items.length; i++) {
-      const afterPos = i + 1;
-      if (afterPos === 1 && !showFirst) continue;
-      if (afterPos % interval !== (showFirst ? 1 : 0)) continue;
-      targets.push(afterPos);
+  // ---------- insertion logic ----------
+
+  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);
+  }
+
+  function injectBetween(kindClass, items, interval, showFirst, allIds, cursorKey) {
+    if (!items.length) return 0;
+
+    const targets = computeTargets(items.length, interval, showFirst);
+    let inserted = 0;
+    const maxInserts = MAX_INSERTS_PER_RUN + (isBoosted() ? 1 : 0);
 
     for (const afterPos of targets) {
-      if (inserted >= MAX_INSERTS_PER_RUN) break;
+      if (inserted >= maxInserts) break;
 
       const el = items[afterPos - 1];
       if (!el || !el.isConnected) continue;
+      if (isAdjacentAd(el)) continue;
       if (findWrap(kindClass, afterPos)) continue;
 
-      const id = pickId(pool);
-      if (!id) break;
-
+      let id = pickIdFromAll(allIds, cursorKey);
+      if (!id) {
+        // No free ids: recycle an old ad wrapper so we can reuse its placeholder id.
+        // Guard against tight observer loops.
+        if (!canRecycle(kindKeyFromClass(kindClass))) {
+          dbg('recycle-skip-cooldown', kindClass);
+          break;
+        }
+        let recycled = false;
+        withInternalDomChange(() => {
+          recycled = removeOneOldWrap(kindClass);
+        });
+        dbg('recycle-needed', kindClass, { recycled, ids: allIds.length });
+        // Stop this run after a recycle; the next mutation/scroll will retry injection.
+        break;
+      }
       const wrap = insertAfter(el, id, kindClass, afterPos);
-      if (!wrap) continue;
+      if (!wrap) {
+        continue;
+      }
 
-      usedSet.add(id);
-      callShowAds(id);
+      observePlaceholder(id);
       inserted += 1;
     }
 
     return inserted;
   }
 
-  async function runCore() {
-    if (!state.canShowAds) return;
-
-    const cfg = await fetchConfig();
-    if (!cfg || cfg.excluded) return;
+  async function insertHeroAdEarly() {
+    if (state.heroDoneForPage) return;
+    const cfg = await fetchConfigOnce();
+    if (!cfg) { dbg('no-config'); return; }
+    if (cfg.excluded) { dbg('excluded'); return; }
 
     initPools(cfg);
 
     const kind = getKind();
-    let inserted = 0;
+    let items = [];
+    let allIds = [];
+    let cursorKey = '';
+    let kindClass = '';
+    let showFirst = false;
 
     if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
-      inserted = injectBetween(
-        'ezoic-ad-message',
-        getPostContainers(),
-        Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
-        normalizeBool(cfg.showFirstMessageAd),
-        state.poolPosts,
-        state.usedPosts
-      );
+      items = getPostContainers();
+      allIds = state.allPosts;
+      cursorKey = 'curPosts';
+      kindClass = 'ezoic-ad-message';
+      showFirst = normalizeBool(cfg.showFirstMessageAd);
     } else if (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
-      inserted = injectBetween(
-        'ezoic-ad-between',
-        getTopicItems(),
-        Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
-        normalizeBool(cfg.showFirstTopicAd),
-        state.poolTopics,
-        state.usedTopics
-      );
+      items = getTopicItems();
+      allIds = state.allTopics;
+      cursorKey = 'curTopics';
+      kindClass = 'ezoic-ad-between';
+      showFirst = normalizeBool(cfg.showFirstTopicAd);
     } else if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
-      inserted = injectBetween(
-        'ezoic-ad-category',
-        getCategoryItems(),
-        Math.max(1, parseInt(cfg.intervalCategories, 10) || 6),
-        normalizeBool(cfg.showFirstCategoryAd),
-        state.poolCategories,
-        state.usedCategories
-      );
+      items = getCategoryItems();
+      allIds = state.allCategories;
+      cursorKey = 'curCategories';
+      kindClass = 'ezoic-ad-categories';
+      showFirst = normalizeBool(cfg.showFirstCategoryAd);
+    } else {
+      return;
     }
+
+    if (!items.length) return;
+    if (!showFirst) { state.heroDoneForPage = true; return; }
+
+    // Insert after the very first item (above-the-fold)
+    const afterPos = 1;
+    const el = items[afterPos - 1];
+    if (!el || !el.isConnected) return;
+    if (isAdjacentAd(el)) return;
+    if (findWrap(kindClass, afterPos)) { state.heroDoneForPage = true; return; }
+
+    const id = pickIdFromAll(allIds, cursorKey);
+    if (!id) return;
+
+    const wrap = insertAfter(el, id, kindClass, afterPos);
+    if (!wrap) {
+      return;
+    }
+
+    state.heroDoneForPage = true;
+    observePlaceholder(id);
   }
 
-  function scheduleRun() {
-    if (state.scheduled) return;
-    state.scheduled = true;
+  async function runCore() {
+    if (isBlocked()) { dbg('blocked'); return; }
+
+    patchShowAds();
+
+    const cfg = await fetchConfigOnce();
+    if (!cfg) { dbg('no-config'); return; }
+    if (cfg.excluded) { dbg('excluded'); return; }
+    initPools(cfg);
+
+    const kind = getKind();
 
-    clearTimeout(state.timer);
-    state.timer = setTimeout(() => {
-      state.scheduled = false;
+    if (kind === 'topic') {
+      if (normalizeBool(cfg.enableMessageAds)) {
+        const __items = getPostContainers();
+        pruneOrphanWraps('ezoic-ad-message', __items);
+        injectBetween(
+          'ezoic-ad-message',
+          __items,
+          Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
+          normalizeBool(cfg.showFirstMessageAd),
+          state.allPosts,
+          'curPosts'
+        );
+      }
+    } else if (kind === 'categoryTopics') {
+      if (normalizeBool(cfg.enableBetweenAds)) {
+        const __items = getTopicItems();
+        pruneOrphanWraps('ezoic-ad-between', __items);
+        injectBetween(
+          'ezoic-ad-between',
+          __items,
+          Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
+          normalizeBool(cfg.showFirstTopicAd),
+          state.allTopics,
+          'curTopics'
+        );
+      }
+    } else if (kind === 'categories') {
+      if (normalizeBool(cfg.enableCategoryAds)) {
+        const __items = getCategoryItems();
+        pruneOrphanWraps('ezoic-ad-categories', __items);
+        injectBetween(
+          'ezoic-ad-categories',
+          __items,
+          Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
+          normalizeBool(cfg.showFirstCategoryAd),
+          state.allCategories,
+          'curCategories'
+        );
+      }
+    }
+  }
+
+  function scheduleRun() {
+    if (state.runQueued) return;
+    state.runQueued = true;
+    window.requestAnimationFrame(() => {
+      state.runQueued = false;
       const pk = getPageKey();
       if (state.pageKey && pk !== state.pageKey) return;
       runCore().catch(() => {});
-    }, 50);
+    });
   }
 
+  // ---------- observers / lifecycle ----------
+
   function cleanup() {
-    const allIds = [...state.usedTopics, ...state.usedPosts, ...state.usedCategories];
-    if (allIds.length) destroyPlaceholderIds(allIds);
+    blockedUntil = Date.now() + 1200;
 
-    document.querySelectorAll('.ezoic-ad').forEach(el => {
-      try { el.remove(); } catch (e) {}
-    });
+    // remove all wrappers
+    try {
+      document.querySelectorAll(`.${WRAP_CLASS}`).forEach((el) => {
+        try { el.remove(); } catch (e) {}
+      });
+    } catch (e) {}
 
-    state.pageKey = getPageKey();
+    // reset state
     state.cfg = null;
-    state.cfgPromise = null;
-    state.poolTopics = [];
-    state.poolPosts = [];
-    state.poolCategories = [];
-    state.usedTopics.clear();
-    state.usedPosts.clear();
-    state.usedCategories.clear();
+    state.allTopics = [];
+    state.allPosts = [];
+    state.allCategories = [];
+    state.curTopics = 0;
+    state.curPosts = 0;
+    state.curCategories = 0;
     state.lastShowById.clear();
-    sessionDefinedIds.clear();
+    state.inflight = 0;
+    state.pending = [];
+    try { state.pendingSet && state.pendingSet.clear(); } catch (e) {}
+    try { state.usedOnce && state.usedOnce.clear(); } catch (e) {}
+    state.heroDoneForPage = false;
 
-    if (state.obs) {
-      state.obs.disconnect();
-      state.obs = null;
-    }
-
-    state.scheduled = false;
-    clearTimeout(state.timer);
-    state.timer = null;
+    // keep observers alive (MutationObserver will re-trigger after navigation)
   }
 
-  function ensureObserver() {
-    if (state.obs) return;
-    state.obs = new MutationObserver(() => scheduleRun());
+  function ensureDomObserver() {
+    if (state.domObs) return;
+    state.domObs = new MutationObserver(() => {
+      if (state.internalDomChange > 0) return;
+      if (!isBlocked()) scheduleRun();
+    });
     try {
-      state.obs.observe(document.body, { childList: true, subtree: true });
+      state.domObs.observe(document.body, { childList: true, subtree: true });
     } catch (e) {}
   }
 
-  function waitForContentThenRun() {
-    const kind = getKind();
-    let selector = SELECTORS.postItem;
-    if (kind === 'categoryTopics') selector = SELECTORS.topicItem;
-    else if (kind === 'categories') selector = SELECTORS.categoryItem;
-
-    const check = () => {
-      if (document.querySelector(selector)) {
-        scheduleRun();
-      } else {
-        setTimeout(check, 200);
-      }
-    };
-    check();
-  }
-
-  function bind() {
+  function bindNodeBB() {
     if (!$) return;
 
     $(window).off('.ezoicInfinite');
-    $(window).on('action:ajaxify.start.ezoicInfinite', () => cleanup());
+
+    $(window).on('action:ajaxify.start.ezoicInfinite', () => {
+      cleanup();
+    });
+
     $(window).on('action:ajaxify.end.ezoicInfinite', () => {
       state.pageKey = getPageKey();
-      ensureObserver();
-      state.canShowAds = true;
-      scheduleRun();
-    });
+      blockedUntil = 0;
+
+      warmUpNetwork();
+      patchShowAds();
+      ensurePreloadObserver();
+      ensureDomObserver();
+
+      // Ultra-fast above-the-fold first
+      insertHeroAdEarly().catch(() => {});
 
-    $(window).on('action:category.loaded.ezoicInfinite', () => {
-      ensureObserver();
-      waitForContentThenRun();
+      // Then normal insertion
+      scheduleRun();
     });
 
-    $(window).on('action:topics.loaded.ezoicInfinite', () => {
-      ensureObserver();
-      waitForContentThenRun();
+    // Infinite scroll / partial updates
+    $(window).on('action:posts.loaded.ezoicInfinite action:topics.loaded.ezoicInfinite action:category.loaded.ezoicInfinite action:topic.loaded.ezoicInfinite', () => {
+      if (isBlocked()) return;
+      scheduleRun();
     });
   }
 
-  function init() {
-    state.pageKey = getPageKey();
-    state.canShowAds = true;
-    bind();
-    ensureObserver();
-    waitForContentThenRun();
+  function bindScroll() {
+    let ticking = false;
+    window.addEventListener('scroll', () => {
+      // Detect very fast scrolling and temporarily boost preload/parallelism.
+      try {
+        const now = Date.now();
+        const y = window.scrollY || window.pageYOffset || 0;
+        if (state.lastScrollTs) {
+          const dt = now - state.lastScrollTs;
+          const dy = Math.abs(y - (state.lastScrollY || 0));
+          if (dt > 0) {
+            const speed = dy / dt; // px/ms
+            if (speed >= BOOST_SPEED_PX_PER_MS) {
+              const wasBoosted = isBoosted();
+              state.scrollBoostUntil = Math.max(state.scrollBoostUntil || 0, now + BOOST_DURATION_MS);
+              if (!wasBoosted) {
+                // margin changed -> rebuild IO so existing placeholders get earlier preload
+                ensurePreloadObserver();
+              }
+            }
+          }
+        }
+        state.lastScrollY = y;
+        state.lastScrollTs = now;
+      } catch (e) {}
+
+      if (ticking) return;
+      ticking = true;
+      window.requestAnimationFrame(() => {
+        ticking = false;
+        if (!isBlocked()) scheduleRun();
+      });
+    }, { passive: true });
   }
 
-  if ($ && $(document).ready) {
-    $(document).ready(init);
-  } else if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', init);
-  } else {
-    init();
-  }
+  // ---------- boot ----------
+
+  state.pageKey = getPageKey();
+  warmUpNetwork();
+  patchShowAds();
+  ensurePreloadObserver();
+  ensureDomObserver();
+
+  bindNodeBB();
+  bindScroll();
+
+  // First paint: try hero + run
+  blockedUntil = 0;
+  insertHeroAdEarly().catch(() => {});
+  scheduleRun();
 })();

package/public/style.css

@@ -1,11 +1,46 @@
+/* Keep Ezoic wrappers “CLS-safe” and remove the extra vertical spacing Ezoic often injects */
 .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;
+  min-height: 1px; /* keeps placeholder measurable for IO */
+}
+
+/* Ezoic sometimes wraps in extra spans/divs with margins */
+.ezoic-ad span.ezoic-ad,
+.ezoic-ad .ezoic-ad {
   margin: 0 !important;
+  padding: 0 !important;
+}
+
+
+/* Collapse empty ad blocks (prevents "holes" when an ad doesn't fill or gets destroyed) */
+.ezoic-ad.is-empty {
+  display: block !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  height: 0 !important;
   min-height: 0 !important;
-  min-width: 0 !important;
+  overflow: hidden !important;
 }
 
-.ezoic-ad * {
+.ezoic-ad {
   min-height: 0 !important;
-  min-width: 0 !important;
+}
+
+.ezoic-ad > [id^="ezoic-pub-ad-placeholder-"] {
+  min-height: 0 !important;
+}
+
+/* Avoid baseline gap under iframes (can look like extra space) */
+.ezoic-ad iframe {
+  display: block !important;
+  vertical-align: top !important;
 }