nodebb-plugin-ezoic-infinite 1.5.20 → 1.5.22

package/library.js

@@ -9,7 +9,11 @@ const plugin = {};
 
 function normalizeExcludedGroups(value) {
   if (!value) return [];
-  if (Array.isArray(value)) return value;
+  // NodeBB settings may return arrays, strings, or objects like {0:'a',1:'b'}
+  if (Array.isArray(value)) return value.map(String).map(s => s.trim()).filter(Boolean);
+  if (typeof value === 'object') {
+    return Object.values(value).map(String).map(s => s.trim()).filter(Boolean);
+  }
   return String(value).split(',').map(s => s.trim()).filter(Boolean);
 }
 
@@ -27,13 +31,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,14 +66,32 @@ async function getSettings() {
 
     excludedGroups: normalizeExcludedGroups(s.excludedGroups),
   };
+  return _settingsCache;
 }
 
 async function isUserExcluded(uid, excludedGroups) {
-  if (!uid || !excludedGroups.length) return false;
-  const userGroups = await groups.getUserGroups([uid]);
-  return (userGroups[0] || []).some(g => excludedGroups.includes(g.name));
+  const list = (excludedGroups || []).map(g => String(g).toLowerCase());
+  const id = Number(uid) || 0;
+
+  if (!list.length) return false;
+
+  // Guests (uid=0) are not in groups.getUserGroups; treat explicitly if configured
+  if (id === 0) {
+    return list.includes('guests') || list.includes('guest');
+  }
+
+  const userGroups = await groups.getUserGroups([id]);
+  const names = (userGroups[0] || []).map(g => (g && g.name) ? g.name : String(g));
+  return names.some(name => list.includes(String(name).toLowerCase()));
 }
 
+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,9 +119,13 @@ 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);
+    const uid = (typeof req.uid !== 'undefined' && req.uid !== null) ? req.uid
+      : (req.user && req.user.uid) ? req.user.uid
+      : (res.locals && res.locals.uid) ? res.locals.uid
+      : 0;
+    const excluded = await isUserExcluded(uid, settings.excludedGroups);
 
     res.json({
       excluded,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.5.20",
+  "version": "1.5.22",
   "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,45 +1,93 @@
 (function () {
   'use strict';
 
-  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
+  var $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
 
-  const SELECTORS = {
+  var SELECTORS = {
     topicItem: 'li[component="category/topic"]',
     postItem: '[component="post"][data-pid]',
-    categoryItem: 'li[component="categories/category"]',
+    categoryItem: 'li[component="categories/category"]'
   };
 
-  const WRAP_CLASS = 'ezoic-ad';
-  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
-  const MAX_INSERTS_PER_RUN = 3;
+  var WRAP_CLASS = 'ezoic-ad';
+  var PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
 
-  const state = {
+  // Hard limits to avoid runaway insertion during mutations / infinite scroll.
+  var MAX_INSERTS_PER_RUN = 3;
+
+  // Placeholders that have been "defined" (filled) at least once in this browser session.
+  // This survives ajaxify navigations, which is important for safe recycle/destroy logic.
+  var sessionDefinedIds = new Set();
+
+  // Prevent re-entrant insertion of the same id while Ezoic is processing it.
+  var insertingIds = new Set();
+
+  var state = {
     pageKey: null,
+
     cfg: null,
     cfgPromise: null,
+
     poolTopics: [],
     poolPosts: [],
     poolCategories: [],
+
     usedTopics: new Set(),
     usedPosts: new Set(),
     usedCategories: new Set(),
+
+    // Track wrappers that are still in the DOM to recycle ids once they are far above viewport.
+    liveTopics: [],
+    livePosts: [],
+    liveCategories: [],
+
+    // Throttle showAds calls per id.
     lastShowById: new Map(),
-    canShowAds: false,
+
+    // Ids for which we scheduled/attempted showAds and should not schedule again immediately.
+    pendingById: new Set(),
+
+    // Timeouts created by this script (so we can cancel on ajaxify.start).
+    activeTimeouts: new Set(),
+
+    // Run scheduling / mutation observer.
     scheduled: false,
     timer: null,
     obs: null,
-  };
 
-  const sessionDefinedIds = new Set();
+    // Scroll throttling.
+    lastScrollRun: 0,
+
+    // Navigation safety gate: we only insert after ajaxify.end settles.
+    canShowAds: false,
+
+    // Retry counters.
+    poolWaitAttempts: 0,
+    awaitItemsAttempts: 0
+  };
 
   function normalizeBool(v) {
     return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
+  function setTimeoutTracked(fn, ms) {
+    var id = setTimeout(fn, ms);
+    state.activeTimeouts.add(id);
+    return id;
+  }
+
+  function clearAllTrackedTimeouts() {
+    state.activeTimeouts.forEach(function (id) {
+      try { clearTimeout(id); } catch (e) {}
+    });
+    state.activeTimeouts.clear();
+  }
+
   function uniqInts(lines) {
-    const out = [], seen = new Set();
-    for (const v of lines) {
-      const n = parseInt(v, 10);
+    var out = [];
+    var seen = new Set();
+    for (var i = 0; i < lines.length; i++) {
+      var n = parseInt(lines[i], 10);
       if (Number.isFinite(n) && n > 0 && !seen.has(n)) {
         seen.add(n);
         out.push(n);
@@ -50,26 +98,34 @@
 
   function parsePool(raw) {
     if (!raw) return [];
-    const lines = String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+    var lines = String(raw)
+      .split(/\r?\n/)
+      .map(function (s) { return s.trim(); })
+      .filter(Boolean);
     return uniqInts(lines);
   }
 
   function getPageKey() {
     try {
-      const ax = window.ajaxify;
+      var 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}`;
+        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 || '';
+    var 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';
   }
 
@@ -77,295 +133,715 @@
     return Array.from(document.querySelectorAll(SELECTORS.topicItem));
   }
 
-  function getPostContainers() {
-    return Array.from(document.querySelectorAll(SELECTORS.postItem));
-  }
-
   function getCategoryItems() {
     return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
   }
 
-  async function fetchConfig() {
-    if (state.cfg) return state.cfg;
-    if (state.cfgPromise) return state.cfgPromise;
+  function getPostContainers() {
+    var nodes = Array.from(document.querySelectorAll(SELECTORS.postItem));
+    return nodes.filter(function (el) {
+      if (!el || !el.isConnected) return false;
+      if (!el.querySelector('[component="post/content"]')) return false;
 
-    state.cfgPromise = (async () => {
-      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;
-      }
-    })();
+      // Prevent nested / duplicated post wrappers.
+      var 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 state.cfgPromise;
+      return true;
+    });
   }
 
-  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);
+  function safeRect(el) {
+    try { return el.getBoundingClientRect(); } catch (e) { return null; }
   }
 
   function destroyPlaceholderIds(ids) {
     if (!ids || !ids.length) return;
-    const filtered = ids.filter(id => Number.isFinite(id) && id > 0);
+
+    // Only destroy ids that were actually "defined" (filled at least once) to avoid Ezoic warnings.
+    var filtered = ids.filter(function (id) {
+      try { return sessionDefinedIds.has(id); } catch (e) { return true; }
+    });
+
     if (!filtered.length) return;
 
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      
-      const call = () => {
-        if (typeof window.ezstandalone.destroyPlaceholders === 'function') {
+    var call = function () {
+      try {
+        if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
           window.ezstandalone.destroyPlaceholders(filtered);
         }
-      };
+      } catch (e) {}
+    };
 
+        try {
+      // Do NOT initialize ezstandalone here; if you load Ezoic elsewhere, it will manage its own queue.
       if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
         call();
-      } else {
+      } else if (window.ezstandalone && window.ezstandalone.cmd && Array.isArray(window.ezstandalone.cmd)) {
         window.ezstandalone.cmd.push(call);
       }
+    } catch (e) {}}
+
+  function getRecyclable(liveArr) {
+    var margin = 600; // px above viewport
+    for (var i = 0; i < liveArr.length; i++) {
+      var entry = liveArr[i];
+      if (!entry || !entry.wrap || !entry.wrap.isConnected) {
+        liveArr.splice(i, 1);
+        i--;
+        continue;
+      }
+      var r = safeRect(entry.wrap);
+      if (r && r.bottom < -margin) {
+        liveArr.splice(i, 1);
+        return entry;
+      }
+    }
+    return null;
+  }
 
-      // Recyclage: libérer après 100ms
-      setTimeout(() => {
-        filtered.forEach(id => sessionDefinedIds.delete(id));
-      }, 100);
-    } catch (e) {}
+  function pickId(pool, liveArr) {
+    if (pool.length) return { id: pool.shift(), recycled: null };
+
+    var recycled = getRecyclable(liveArr);
+    if (recycled) return { id: recycled.id, recycled: recycled };
+
+    return { id: null, recycled: null };
   }
 
-  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%';
+  function resetPlaceholderInWrap(wrap, id) {
+    if (!wrap) return null;
+    try { wrap.innerHTML = ''; } catch (e) {}
 
-    const ph = document.createElement('div');
-    ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+    var ph = document.createElement('div');
+    ph.id = PLACEHOLDER_PREFIX + id;
     wrap.appendChild(ph);
+    return ph;
+  }
+
+  function isAdjacentAd(el) {
+    var next = el && el.nextElementSibling;
+    return !!(next && next.classList && next.classList.contains(WRAP_CLASS));
+  }
+
+  function isPrevAd(el) {
+    var prev = el && el.previousElementSibling;
+    return !!(prev && prev.classList && prev.classList.contains(WRAP_CLASS));
+  }
+
+  function buildWrap(id, kindClass) {
+    var wrap = document.createElement('div');
+    wrap.className = WRAP_CLASS + ' ' + kindClass;
+    wrap.setAttribute('data-ezoic-id', String(id));
+    resetPlaceholderInWrap(wrap, id);
     return wrap;
   }
 
   function findWrap(kindClass, afterPos) {
-    return document.querySelector(`.${WRAP_CLASS}.${kindClass}[data-ezoic-after="${afterPos}"]`);
+    // Search a wrapper marker that we set on insertion.
+    return document.querySelector('.' + kindClass + '[data-after-pos="' + afterPos + '"]');
   }
 
-  function insertAfter(target, id, kindClass, afterPos) {
-    if (!target || !target.insertAdjacentElement) return null;
-    if (findWrap(kindClass, afterPos)) return null;
-
+  function insertAfter(el, id, kindClass, afterPos) {
     try {
-      const wrap = buildWrap(id, kindClass, afterPos);
-      target.insertAdjacentElement('afterend', wrap);
+      var wrap = buildWrap(id, kindClass);
+      wrap.setAttribute('data-after-pos', String(afterPos));
+
+      if (!el || !el.parentNode) return null;
+      if (el.nextSibling) el.parentNode.insertBefore(wrap, el.nextSibling);
+      else el.parentNode.appendChild(wrap);
+
+      attachFillObserver(wrap, id);
       return wrap;
-    } catch (e) {
-      return null;
-    }
+    } catch (e) {}
+    return null;
   }
 
-  function pickId(pool) {
-    if (!pool || !pool.length) return null;
-    return pool.shift();
+  function destroyUsedPlaceholders() {
+    var ids = [];
+    state.usedTopics.forEach(function (id) { ids.push(id); });
+    state.usedPosts.forEach(function (id) { ids.push(id); });
+    state.usedCategories.forEach(function (id) { ids.push(id); });
+
+    // Only destroy placeholders that were filled at least once in this session.
+    destroyPlaceholderIds(ids);
   }
 
-  function callShowAds(id) {
-    if (!id) return;
-    
+  function patchShowAds() {
+    // Intentionally left blank: ezstandalone is managed elsewhere.
+  }
+
+  function markFilled(id) {
+    try { sessionDefinedIds.add(id); } catch (e) {}
+  }
+
+  function isWrapMarkedFilled(wrap) {
+    try { return !!(wrap && wrap.getAttribute && wrap.getAttribute('data-ezoic-filled') === '1'); } catch (e) { return false; }
+  }
+
+  function attachFillObserver(wrap, id) {
+    if (!wrap || !wrap.isConnected) return;
+
+    // If already filled, mark and return.
+    if (isPlaceholderFilled(wrap)) {
+      try { wrap.setAttribute('data-ezoic-filled', '1'); } catch (e) {}
+      markFilled(id);
+      return;
+    }
+
+    // Observe for Ezoic inserting ad content into placeholder.
     try {
-      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);
+      var obs = new MutationObserver(function () {
+        if (!wrap.isConnected) {
+          try { obs.disconnect(); } catch (e) {}
+          return;
+        }
+        if (isPlaceholderFilled(wrap)) {
+          try { wrap.setAttribute('data-ezoic-filled', '1'); } catch (e) {}
+          markFilled(id);
+          try { obs.disconnect(); } catch (e) {}
         }
       });
+      obs.observe(wrap, { childList: true, subtree: true });
+      wrap.__ezoicFillObs = obs;
+    } catch (e) {}
+  }
+
+  function isPlaceholderFilled(wrap) {
+    // Heuristic: placeholder exists AND has descendants or meaningful height.
+    try {
+      var ph = wrap.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
+      if (!ph) return false;
+      if (ph.children && ph.children.length) return true;
+      var r = safeRect(wrap);
+      if (r && r.height > 20) return true;
     } catch (e) {}
+    return false;
   }
 
-  function injectBetween(kindClass, items, interval, showFirst, pool, usedSet) {
-    if (!items || items.length === 0) return 0;
+  function scheduleShowAdsBatch(ids) {
+    if (!ids || !ids.length) return;
 
-    let inserted = 0;
-    const targets = [];
+    // Ezoic expects DOM to be settled.
+    var call = function () {
+      try {
+        if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') {
+          window.ezstandalone.showAds(ids);
+        }
+      } 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);
+    try {
+      if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') call();
+      else if (window.ezstandalone && window.ezstandalone.cmd && Array.isArray(window.ezstandalone.cmd)) window.ezstandalone.cmd.push(call);
+    } catch (e) {}
+  }
+
+  function callShowAdsWhenReady(id) {
+    if (!id) return;
+
+    // Throttle per-id.
+    var now = Date.now();
+    var last = state.lastShowById.get(id) || 0;
+    if (now - last < 1200) return;
+
+    if (state.pendingById.has(id)) return;
+    state.pendingById.add(id);
+    state.lastShowById.set(id, now);
+
+    // Guard against re-entrancy.
+    if (insertingIds.has(id)) {
+      state.pendingById.delete(id);
+      return;
     }
+    insertingIds.add(id);
+
+    var attempts = 0;
 
-    for (const afterPos of targets) {
+    (function waitForPh() {
+      attempts++;
+
+      // Navigation safety: if we navigated away, stop.
+      if (!state.canShowAds) {
+        state.pendingById.delete(id);
+        insertingIds.delete(id);
+        return;
+      }
+
+      var ph = document.getElementById(PLACEHOLDER_PREFIX + id);
+
+      var doCall = function () {
+        try {
+          // If placeholder is gone, stop.
+          if (!ph || !ph.isConnected) return false;
+          scheduleShowAdsBatch([id]);
+          return true;
+        } catch (e) {}
+        return false;
+      };
+
+      if (ph && ph.isConnected) {
+        doCall();
+        state.pendingById.delete(id);
+        insertingIds.delete(id);
+        return;
+      }
+
+      if (attempts < 100) {
+        setTimeoutTracked(waitForPh, 50);
+        return;
+      }
+
+      // Timeout: give up silently.
+      state.pendingById.delete(id);
+      insertingIds.delete(id);
+    })();
+  }
+
+  function initPools(cfg) {
+    if (!state.poolTopics.length) state.poolTopics = parsePool(cfg.placeholderIds);
+    if (!state.poolPosts.length) state.poolPosts = parsePool(cfg.messagePlaceholderIds);
+    if (!state.poolCategories.length) state.poolCategories = parsePool(cfg.categoryPlaceholderIds);
+  }
+
+  function computeTargets(count, interval, showFirst) {
+    var out = [];
+    if (count <= 0) return out;
+
+    if (showFirst) out.push(1);
+
+    for (var i = 1; i <= count; i++) {
+      if (i % interval === 0) out.push(i);
+    }
+
+    // Unique + sorted.
+    return Array.from(new Set(out)).sort(function (a, b) { return a - b; });
+  }
+
+  function injectBetween(kindClass, items, interval, showFirst, kindPool, usedSet, liveArr) {
+    if (!items || !items.length) return 0;
+
+    var targets = computeTargets(items.length, interval, showFirst);
+    var inserted = 0;
+
+    for (var t = 0; t < targets.length; t++) {
+      var afterPos = targets[t];
       if (inserted >= MAX_INSERTS_PER_RUN) break;
 
-      const el = items[afterPos - 1];
+      var el = items[afterPos - 1];
       if (!el || !el.isConnected) continue;
+
+      // Prevent adjacent ads.
+      if (isAdjacentAd(el) || isPrevAd(el)) continue;
+
+      // Prevent duplicates at same logical position.
+      if (findWrap(kindClass, afterPos - 1)) continue;
       if (findWrap(kindClass, afterPos)) continue;
 
-      const id = pickId(pool);
+      var pick = pickId(kindPool, liveArr);
+      var id = pick.id;
       if (!id) break;
 
-      const wrap = insertAfter(el, id, kindClass, afterPos);
-      if (!wrap) continue;
+      var wrap = null;
+
+      if (pick.recycled && pick.recycled.wrap) {
+        // Recycle: only destroy if Ezoic has actually defined this placeholder before.
+        if (sessionDefinedIds.has(id)) destroyPlaceholderIds([id]);
+
+        // Remove old wrapper.
+        var oldWrap = pick.recycled.wrap;
+        try { if (oldWrap && oldWrap.__ezoicFillObs) oldWrap.__ezoicFillObs.disconnect(); } catch (e) {}
+        try { if (oldWrap) oldWrap.remove(); } catch (e) {}
+
+        wrap = insertAfter(el, id, kindClass, afterPos);
+        if (!wrap) continue;
 
-      usedSet.add(id);
-      callShowAds(id);
-      inserted += 1;
+        // Give Ezoic a moment after DOM insertion.
+        setTimeoutTracked(function () { callShowAdsWhenReady(id); }, 700);
+      } else {
+        usedSet.add(id);
+        wrap = insertAfter(el, id, kindClass, afterPos);
+        if (!wrap) continue;
+
+        // Micro-delay to allow layout/DOM settle.
+        setTimeoutTracked(function () { callShowAdsWhenReady(id); }, 10);
+      }
+
+      liveArr.push({ id: id, wrap: wrap });
+
+      // Final safety: if adjacency happened due to DOM shifts, rollback.
+      var prev = wrap && wrap.previousElementSibling;
+      var next = wrap && wrap.nextElementSibling;
+      if (wrap && ((prev && prev.classList && prev.classList.contains(WRAP_CLASS)) || (next && next.classList && next.classList.contains(WRAP_CLASS)))) {
+        try { wrap.remove(); } catch (e) {}
+
+        if (!(pick.recycled && pick.recycled.wrap)) {
+          try { kindPool.unshift(id); } catch (e) {}
+          usedSet.delete(id);
+        }
+        continue;
+      }
+
+      inserted++;
     }
 
     return inserted;
   }
 
-  async function runCore() {
-    if (!state.canShowAds) return;
-
-    const cfg = await fetchConfig();
-    if (!cfg || cfg.excluded) return;
-
-    initPools(cfg);
-
-    const kind = getKind();
-    let inserted = 0;
-
-    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
-      );
-    } 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
-      );
-    } 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
-      );
+  function enforceNoAdjacentAds() {
+    var ads = Array.from(document.querySelectorAll('.' + WRAP_CLASS));
+    for (var i = 0; i < ads.length; i++) {
+      var ad = ads[i];
+      var prev = ad.previousElementSibling;
+
+      if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) {
+        // Remove adjacent wrapper (do not hide).
+        try {
+          var ph = ad.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
+          if (ph) {
+            var id = parseInt(ph.id.replace(PLACEHOLDER_PREFIX, ''), 10);
+            if (Number.isFinite(id) && id > 0 && sessionDefinedIds.has(id)) {
+              destroyPlaceholderIds([id]);
+            }
+          }
+          ad.remove();
+        } catch (e) {}
+      }
     }
   }
 
-  function scheduleRun() {
-    if (state.scheduled) return;
-    state.scheduled = true;
+  function cleanup() {
+    // Stop any insertion during navigation / DOM teardown.
+    state.canShowAds = false;
+    state.poolWaitAttempts = 0;
+    state.awaitItemsAttempts = 0;
 
-    clearTimeout(state.timer);
-    state.timer = setTimeout(() => {
-      state.scheduled = false;
-      const pk = getPageKey();
-      if (state.pageKey && pk !== state.pageKey) return;
-      runCore().catch(() => {});
-    }, 50);
-  }
+    // Cancel any pending showAds timeouts.
+    clearAllTrackedTimeouts();
 
-  function cleanup() {
-    const allIds = [...state.usedTopics, ...state.usedPosts, ...state.usedCategories];
-    if (allIds.length) destroyPlaceholderIds(allIds);
+    // Disconnect global observer to avoid mutations during teardown.
+    if (state.obs) {
+      try { state.obs.disconnect(); } catch (e) {}
+      state.obs = null;
+    }
 
-    document.querySelectorAll('.ezoic-ad').forEach(el => {
-      try { el.remove(); } catch (e) {}
-    });
+    // Destroy placeholders that were used (only those that were actually defined).
+    destroyUsedPlaceholders();
 
+    // Remove wrappers from DOM (safe because insertion is now blocked).
+    try {
+      document.querySelectorAll('.' + WRAP_CLASS).forEach(function (el) {
+        try { if (el && el.__ezoicFillObs) el.__ezoicFillObs.disconnect(); } catch (e) {}
+        try { el.remove(); } catch (e) {}
+      });
+    } catch (e) {}
+
+    // Reset runtime caches.
     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();
-    sessionDefinedIds.clear();
 
-    if (state.obs) {
-      state.obs.disconnect();
-      state.obs = null;
-    }
+    state.liveTopics = [];
+    state.livePosts = [];
+    state.liveCategories = [];
+
+    state.lastShowById.clear();
+    state.pendingById.clear();
+    insertingIds.clear();
 
     state.scheduled = false;
-    clearTimeout(state.timer);
-    state.timer = null;
+    if (state.timer) {
+      try { clearTimeout(state.timer); } catch (e) {}
+      state.timer = null;
+    }
   }
 
   function ensureObserver() {
     if (state.obs) return;
-    state.obs = new MutationObserver(() => scheduleRun());
     try {
+      state.obs = new MutationObserver(function () { scheduleRun('mutation'); });
       state.obs.observe(document.body, { childList: true, subtree: true });
     } catch (e) {}
   }
 
+  function scheduleRun(/* reason */) {
+    if (state.scheduled) return;
+    state.scheduled = true;
+
+    if (state.timer) {
+      try { clearTimeout(state.timer); } catch (e) {}
+      state.timer = null;
+    }
+
+    state.timer = setTimeoutTracked(function () {
+      state.scheduled = false;
+
+      // If user navigated away, stop.
+      var pk = getPageKey();
+      if (state.pageKey && pk !== state.pageKey) return;
+
+      runCore().catch(function () {});
+    }, 80);
+  }
+
+  function waitForItemsThenRun(kind) {
+    // If list isn't in DOM yet (ajaxify transition), retry a bit.
+    var 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) return true;
+
+    if (state.awaitItemsAttempts < 25) {
+      state.awaitItemsAttempts++;
+      setTimeoutTracked(function () { scheduleRun('await-items'); }, 120);
+    }
+    return false;
+  }
+
   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();
+    // Avoid inserting ads on pages with too little content.
+    var MIN_WORDS = 250;
+    var attempts = 0;
+    var maxAttempts = 20; // 20 × 200ms = 4s
+
+    (function check() {
+      attempts++;
+
+      var text = '';
+      try { text = document.body.innerText || ''; } catch (e) {}
+      var wordCount = text.split(/\s+/).filter(Boolean).length;
+
+      if (wordCount >= MIN_WORDS) {
+        scheduleRun('content-ok');
+        return;
+      }
+
+      if (attempts >= maxAttempts) {
+        scheduleRun('content-timeout');
+        return;
+      }
+
+      setTimeoutTracked(check, 200);
+    })();
+  }
+
+  function waitForEzoicThenRun() {
+    var attempts = 0;
+    var maxAttempts = 50; // 50 × 200ms = 10s
+
+    (function check() {
+      attempts++;
+
+      if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') {
+        scheduleRun('ezoic-ready');
+        waitForContentThenRun();
+        return;
+      }
+
+      if (attempts >= maxAttempts) {
+        scheduleRun('ezoic-timeout');
+        return;
+      }
+
+      setTimeoutTracked(check, 200);
+    })();
+  }
+
+  function fetchConfig() {
+    if (state.cfg) return Promise.resolve(state.cfg);
+    if (state.cfgPromise) return state.cfgPromise;
+
+    state.cfgPromise = (function () {
+      var MAX_TRIES = 3;
+      var delay = 800;
+
+      function attemptFetch(attempt) {
+        return fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' })
+          .then(function (res) {
+            if (!res || !res.ok) throw new Error('bad response');
+            return res.json();
+          })
+          .then(function (json) {
+            state.cfg = json;
+            return json;
+          })
+          .catch(function () {
+            if (attempt >= MAX_TRIES) return null;
+            return new Promise(function (r) { setTimeoutTracked(r, delay); }).then(function () {
+              delay *= 2;
+              return attemptFetch(attempt + 1);
+            });
+          });
+      }
+
+      return attemptFetch(1).finally(function () { state.cfgPromise = null; });
+    })();
+
+    return state.cfgPromise;
+  }
+
+  function runCore() {
+    // Navigation safety: never insert during ajaxify teardown.
+    if (!state.canShowAds) return Promise.resolve();
+
+    patchShowAds();
+
+    return fetchConfig().then(function (cfg) {
+      if (!cfg || cfg.excluded) return;
+
+      initPools(cfg);
+
+      var kind = getKind();
+      var inserted = 0;
+
+      if (!waitForItemsThenRun(kind)) return;
+
+      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,
+            state.livePosts
+          );
+        }
+      } 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,
+            state.liveTopics
+          );
+        }
+      } 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,
+            state.liveCategories
+          );
+        }
+      }
+
+      enforceNoAdjacentAds();
+
+      // Recycling: if pool is exhausted, retry a few times to allow old wrappers to scroll off-screen.
+      if (inserted === 0) {
+        if (state.poolWaitAttempts < 8) {
+          state.poolWaitAttempts++;
+          setTimeoutTracked(function () { scheduleRun('pool-wait'); }, 400);
+        }
       } else {
-        setTimeout(check, 200);
+        // Reset pool wait attempts once we successfully insert something.
+        state.poolWaitAttempts = 0;
       }
-    };
-    check();
+
+      // If we hit max inserts, continue quickly.
+      if (inserted >= MAX_INSERTS_PER_RUN) {
+        setTimeoutTracked(function () { scheduleRun('continue'); }, 140);
+      }
+    }).catch(function () {});
   }
 
   function bind() {
     if (!$) return;
 
     $(window).off('.ezoicInfinite');
-    $(window).on('action:ajaxify.start.ezoicInfinite', () => cleanup());
-    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
+
+    $(window).on('action:ajaxify.start.ezoicInfinite', function () {
+      cleanup();
+    });
+
+    $(window).on('action:ajaxify.end.ezoicInfinite', function () {
       state.pageKey = getPageKey();
       ensureObserver();
-      state.canShowAds = true;
-      scheduleRun();
+
+      // Delay gate to avoid racing NodeBB DOM swap vs Ezoic processing.
+      setTimeoutTracked(function () {
+        state.canShowAds = true;
+        waitForEzoicThenRun();
+      }, 300);
     });
 
-    $(window).on('action:category.loaded.ezoicInfinite', () => {
+    // Infinite-scroll and "loaded" events.
+    $(window).on('action:category.loaded.ezoicInfinite', function () {
       ensureObserver();
       waitForContentThenRun();
     });
 
-    $(window).on('action:topics.loaded.ezoicInfinite', () => {
+    $(window).on('action:topics.loaded.ezoicInfinite', function () {
       ensureObserver();
       waitForContentThenRun();
     });
-  }
 
-  function init() {
-    state.pageKey = getPageKey();
-    state.canShowAds = true;
-    bind();
-    ensureObserver();
-    waitForContentThenRun();
+    $(window).on('action:topic.loaded.ezoicInfinite', function () {
+      ensureObserver();
+      waitForContentThenRun();
+    });
+
+    $(window).on('action:posts.loaded.ezoicInfinite', function () {
+      ensureObserver();
+      waitForContentThenRun();
+    });
   }
 
-  if ($ && $(document).ready) {
-    $(document).ready(init);
-  } else if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', init);
-  } else {
-    init();
+  function bindScroll() {
+    if (state.lastScrollRun > 0) return;
+    state.lastScrollRun = Date.now();
+
+    var ticking = false;
+    window.addEventListener('scroll', function () {
+      if (ticking) return;
+      ticking = true;
+
+      window.requestAnimationFrame(function () {
+        ticking = false;
+
+        enforceNoAdjacentAds();
+
+        // Debounce scheduleRun (max once every 2s on scroll).
+        var now = Date.now();
+        if (!state.lastScrollRun || (now - state.lastScrollRun > 2000)) {
+          state.lastScrollRun = now;
+          scheduleRun('scroll');
+        }
+      });
+    }, { passive: true });
   }
+
+  // Boot.
+  cleanup();
+  bind();
+  bindScroll();
+  ensureObserver();
+
+  state.pageKey = getPageKey();
+
+  // Direct page load: allow insertion after initial tick (no ajaxify.end).
+  setTimeoutTracked(function () {
+    state.canShowAds = true;
+    waitForEzoicThenRun();
+  }, 0);
 })();

package/public/style.css

@@ -1,11 +1,21 @@
+/* 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;
-  min-height: 0 !important;
-  min-width: 0 !important;
+  padding: 0 !important;
+  min-height: 1px; /* keeps placeholder measurable for IO */
 }
 
-.ezoic-ad * {
-  min-height: 0 !important;
-  min-width: 0 !important;
+/* Ezoic sometimes wraps in extra spans/divs with margins */
+.ezoic-ad span.ezoic-ad,
+.ezoic-ad .ezoic-ad {
+  margin: 0 !important;
+  padding: 0 !important;
 }