nodebb-plugin-ezoic-infinite 1.5.28 → 1.5.30

package/package.json

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

package/public/client.js

@@ -13,27 +13,23 @@
   // Preload before viewport (tune if you want even earlier)
   const PRELOAD_ROOT_MARGIN = '1200px 0px';
 
-  // Windowing: keep ads mostly around the viewport to avoid DOM bloat + ID saturation
-  const WINDOW_MIN_ITEMS = 24;        // minimum scan window
-  const WINDOW_MAX_ITEMS = 120;       // maximum scan window
-  const WINDOW_BUFFER_PX = 900;       // how far outside viewport counts as "near"
-  const PURGE_BUFFER_ITEMS = 12;      // extra items outside the window where we keep wrappers
-  const RECYCLE_COOLDOWN_MS = 1500;   // anti-loop when at saturation / heavy churn
-
-  // Soft-block during navigation or heavy DOM churn (avoid "placeholder does not exist" spam)
-  let EZOIC_BLOCKED_UNTIL = 0;
-
   const SELECTORS = {
     topicItem: 'li[component="category/topic"]',
     postItem: '[component="post"][data-pid]',
     categoryItem: 'li[component="categories/category"]',
   };
 
+  // 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,
 
-    // Full ID lists + cursors (round-robin)
+    // Full lists (never consumed) + cursors for round-robin reuse
     allTopics: [],
     allPosts: [],
     allCategories: [],
@@ -43,6 +39,11 @@
 
     // throttle per placeholder id
     lastShowById: new Map(),
+    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,
@@ -51,28 +52,22 @@
 
     // hero
     heroDoneForPage: false,
-
-    // internal DOM changes (to ignore our own mutations)
-    internalDomChange: 0,
-
-    // recycle cooldown per kind
-    lastRecycleAt: {
-      topic: 0,
-      categoryTopics: 0,
-      categories: 0,
-    },
   };
 
-  // ---------- debug ----------
-  function debugEnabled() {
-    try { return window.localStorage && window.localStorage.getItem('ezoicInfiniteDebug') === '1'; } catch (e) { return false; }
-  }
-  function debug(...args) {
-    if (!debugEnabled()) return;
-    try { console.log('[ezoicInfinite]', ...args); } catch (e) {}
+  const insertingIds = new Set();
+
+  // Debug logs (enable with localStorage.ezoicInfiniteDebug = "1")
+  function dbg(...args) {
+    try {
+      if (window && window.localStorage && window.localStorage.getItem('ezoicInfiniteDebug') === '1') {
+        // eslint-disable-next-line no-console
+        console.log('[ezoicInfinite]', ...args);
+      }
+    } catch (e) {}
   }
 
   // ---------- small utils ----------
+
   function normalizeBool(v) {
     return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
@@ -99,16 +94,6 @@
     return uniqInts(lines);
   }
 
-  function isBlocked() {
-    return Date.now() < EZOIC_BLOCKED_UNTIL;
-  }
-
-  function softBlock(ms) {
-    const until = Date.now() + Math.max(0, ms || 0);
-    if (until > EZOIC_BLOCKED_UNTIL) EZOIC_BLOCKED_UNTIL = until;
-    debug('blocked', { until: EZOIC_BLOCKED_UNTIL });
-  }
-
   function getPageKey() {
     try {
       const ax = window.ajaxify;
@@ -153,12 +138,8 @@
     });
   }
 
-  function withInternalDomChange(fn) {
-    state.internalDomChange++;
-    try { return fn(); } finally { state.internalDomChange--; }
-  }
-
   // ---------- warm-up & patching ----------
+
   const _warmLinksDone = new Set();
   function warmUpNetwork() {
     try {
@@ -225,7 +206,29 @@
     }
   }
 
-  // ---------- config & ids ----------
+    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 {
@@ -238,7 +241,7 @@
     }
   }
 
-  function initIds(cfg) {
+  function initPools(cfg) {
     if (!cfg) return;
     if (state.allTopics.length === 0) state.allTopics = parsePool(cfg.placeholderIds);
     if (state.allPosts.length === 0) state.allPosts = parsePool(cfg.messagePlaceholderIds);
@@ -246,6 +249,7 @@
   }
 
   // ---------- insertion primitives ----------
+
   function isAdjacentAd(target) {
     if (!target) return false;
     const next = target.nextElementSibling;
@@ -255,9 +259,75 @@
     return false;
   }
 
-  function buildWrap(id, kindClass, afterPos) {
+  
+  function getWrapIdFromWrap(wrap) {
+    try {
+      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;
+  }
+
+  function safeDestroyById(id) {
+    try {
+      const ez = window.ezstandalone;
+      if (ez && typeof ez.destroyPlaceholders === 'function') {
+        ez.destroyPlaceholders([`${PLACEHOLDER_PREFIX}${id}`]);
+      }
+    } catch (e) {}
+  }
+
+  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} is-empty`;
+    wrap.className = `${WRAP_CLASS} ${kindClass}`;
     wrap.setAttribute('data-ezoic-after', String(afterPos));
     wrap.setAttribute('data-ezoic-wrapid', String(id));
     wrap.style.width = '100%';
@@ -277,68 +347,26 @@
   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;
 
-    return withInternalDomChange(() => {
+    insertingIds.add(id);
+    try {
       const wrap = buildWrap(id, kindClass, afterPos);
       target.insertAdjacentElement('afterend', wrap);
       return wrap;
-    });
-  }
-
-  function destroyPlaceholderId(id) {
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      const ez = window.ezstandalone;
-      if (typeof ez.destroyPlaceholders === 'function') {
-        try { ez.destroyPlaceholders(id); } catch (e) {}
-      } else if (ez.cmd && Array.isArray(ez.cmd)) {
-        ez.cmd.push(() => {
-          try {
-            if (typeof window.ezstandalone.destroyPlaceholders === 'function') {
-              window.ezstandalone.destroyPlaceholders(id);
-            }
-          } catch (e) {}
-        });
-      }
-    } catch (e) {}
-  }
-
-  function canRecycle(kind) {
-    const now = Date.now();
-    if (now - (state.lastRecycleAt[kind] || 0) < RECYCLE_COOLDOWN_MS) return false;
-    state.lastRecycleAt[kind] = now;
-    return true;
-  }
-
-  function purgeOutsideWindow(kindClass, keepFrom, keepTo) {
-    // Remove wrappers too far away to free placeholder ids + reduce DOM bloat
-    const wraps = Array.from(document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`));
-    if (!wraps.length) return 0;
-
-    let removed = 0;
-    withInternalDomChange(() => {
-      for (const w of wraps) {
-        const afterPos = parseInt(w.getAttribute('data-ezoic-after') || '', 10);
-        if (!Number.isFinite(afterPos)) continue;
-        if (afterPos >= keepFrom && afterPos <= keepTo) continue;
-
-        const id = parseInt(w.getAttribute('data-ezoic-wrapid') || '', 10);
-        if (Number.isFinite(id) && id > 0) destroyPlaceholderId(id);
-
-        try { w.remove(); removed++; } catch (e) {}
-      }
-    });
-    return removed;
+    } finally {
+      insertingIds.delete(id);
+    }
   }
 
   function pickIdFromAll(allIds, cursorKey) {
     const n = allIds.length;
     if (!n) return null;
 
-    // Try at most n IDs to find one not currently present
+    // 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;
@@ -346,24 +374,38 @@
       const id = allIds[idx];
       const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
       if (ph && ph.isConnected) continue;
+
       return id;
     }
     return null;
   }
 
-  function markEmptyLater(id) {
-    // Collapse empty blocks if ad never fills
-    window.setTimeout(() => {
+
+  function removeOneOldWrap(kindClass) {
+    try {
+      const wraps = Array.from(document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`));
+      if (!wraps.length) return false;
+
+      // Prefer a wrap far above the viewport
+      let victim = null;
+      for (const w of wraps) {
+        const r = w.getBoundingClientRect();
+        if (r.bottom < -2000) { victim = w; break; }
+      }
+      // Otherwise remove the earliest one in the document
+      if (!victim) victim = wraps[0];
+
+      // Unobserve placeholder if still observed
       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;
-        if (hasContent) wrap.classList.remove('is-empty');
-        else wrap.classList.add('is-empty');
+        const ph = victim.querySelector && victim.querySelector(`[id^="${PLACEHOLDER_PREFIX}"]`);
+        if (ph && state.io) state.io.unobserve(ph);
       } catch (e) {}
-    }, 1800);
+
+      victim.remove();
+      return true;
+    } catch (e) {
+      return false;
+    }
   }
 
   function showAd(id) {
@@ -373,27 +415,36 @@
     const last = state.lastShowById.get(id) || 0;
     if (now - last < 1500) return; // basic throttle
 
-    const doShow = () => {
+    // Defer one frame so the placeholder is definitely in DOM after insertion/recycle
+    requestAnimationFrame(() => {
       if (isBlocked()) return;
+
       const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
       if (!ph || !ph.isConnected) return;
 
-      state.lastShowById.set(id, Date.now());
-
-      // mark empty by default; remove later if filled
-      try {
-        const wrap = ph.closest(`.${WRAP_CLASS}`);
-        if (wrap) wrap.classList.add('is-empty');
-      } catch (e) {}
+      const now2 = Date.now();
+      const last2 = state.lastShowById.get(id) || 0;
+      if (now2 - last2 < 1200) return;
+      state.lastShowById.set(id, now2);
 
       try {
         window.ezstandalone = window.ezstandalone || {};
         const ez = window.ezstandalone;
 
+        const doShow = () => {
+          try {
+            if (state.usedOnce && state.usedOnce.has(id) && typeof ez.destroyPlaceholders === 'function') {
+              // Avoid Ezoic caching state for reused placeholders
+              ez.destroyPlaceholders(id);
+            }
+          } catch (e) {}
+          try { ez.showAds(id); } catch (e) {}
+          try { state.usedOnce && state.usedOnce.add(id); } catch (e) {}
+        };
+
         // Fast path
         if (typeof ez.showAds === 'function') {
-          ez.showAds(id);
-          markEmptyLater(id);
+          doShow();
           return;
         }
 
@@ -406,19 +457,25 @@
               if (isBlocked()) return;
               const el = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
               if (!el || !el.isConnected) return;
-              window.ezstandalone.showAds(id);
-              markEmptyLater(id);
+              const ez2 = window.ezstandalone;
+              if (!ez2 || typeof ez2.showAds !== 'function') return;
+              try {
+                if (state.usedOnce && state.usedOnce.has(id) && typeof ez2.destroyPlaceholders === 'function') {
+                  ez2.destroyPlaceholders(id);
+                }
+              } catch (e) {}
+              try { ez2.showAds(id); } catch (e) {}
+              try { state.usedOnce && state.usedOnce.add(id); } catch (e) {}
             } catch (e) {}
           });
         }
       } catch (e) {}
-    };
-
-    // Defer one frame to reduce "element does not exist" warnings
-    window.requestAnimationFrame(doShow);
+    });
   }
 
+
   // ---------- preload / above-the-fold ----------
+
   function ensurePreloadObserver() {
     if (state.io) return state.io;
     try {
@@ -452,72 +509,22 @@
     } catch (e) {}
   }
 
-  // ---------- windowed insertion logic ----------
-  function estimateWindowItems(interval, idsCount) {
-    // Ensure we can roughly keep "every X" within the window using available ids
-    // If ids are low, keep a smaller window to avoid constant recycling.
-    const base = Math.max(WINDOW_MIN_ITEMS, Math.floor((idsCount || 1) * Math.max(1, interval) * 1.1));
-    return Math.min(WINDOW_MAX_ITEMS, base);
-  }
-
-  function getVisibleRange(items) {
-    // Returns [startIdx, endIdx] (0-based, inclusive) for items near viewport
-    let start = 0;
-    let end = items.length - 1;
-    let foundAny = false;
-
-    const topBound = -WINDOW_BUFFER_PX;
-    const bottomBound = window.innerHeight + WINDOW_BUFFER_PX;
-
-    for (let i = 0; i < items.length; i++) {
-      const el = items[i];
-      if (!el || !el.isConnected) continue;
-      let r;
-      try { r = el.getBoundingClientRect(); } catch (e) { continue; }
-      if (r.bottom < topBound) { start = i + 1; continue; }
-      if (r.top > bottomBound) { end = i - 1; break; }
-      foundAny = true;
-    }
-
-    if (!foundAny) return [0, Math.min(items.length - 1, 30)];
-    start = Math.max(0, Math.min(start, items.length - 1));
-    end = Math.max(start, Math.min(end, items.length - 1));
-    return [start, end];
-  }
+  // ---------- insertion logic ----------
 
-  function computeTargetsInRange(fromPos, toPos, interval, showFirst) {
+  function computeTargets(count, interval, showFirst) {
     const out = [];
-    if (toPos < fromPos) return out;
-
-    if (showFirst && 1 >= fromPos && 1 <= toPos) out.push(1);
-
-    const startK = Math.ceil(fromPos / interval) * interval;
-    for (let p = startK; p <= toPos; p += interval) out.push(p);
-
-    return 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 injectWindowed(kind, kindClass, items, interval, showFirst, allIds, cursorKey) {
+  function injectBetween(kindClass, items, interval, showFirst, allIds, cursorKey) {
     if (!items.length) return 0;
 
-    const idsCount = allIds.length;
-    const windowItems = estimateWindowItems(interval, idsCount);
-
-    const [visStart, visEnd] = getVisibleRange(items);
-    const mid = Math.floor((visStart + visEnd) / 2);
-    const winStartIdx = Math.max(0, mid - Math.floor(windowItems / 2));
-    const winEndIdx = Math.min(items.length - 1, winStartIdx + windowItems - 1);
-
-    const keepFrom = Math.max(1, (winStartIdx + 1) - PURGE_BUFFER_ITEMS);
-    const keepTo = Math.min(items.length, (winEndIdx + 1) + PURGE_BUFFER_ITEMS);
-
-    const purged = purgeOutsideWindow(kindClass, keepFrom, keepTo);
-    if (purged) debug('purge', kindClass, { purged, keepFrom, keepTo });
-
-    const fromPos = winStartIdx + 1;
-    const toPos = winEndIdx + 1;
-
-    const targets = computeTargetsInRange(fromPos, toPos, interval, showFirst);
+    const targets = computeTargets(items.length, interval, showFirst);
     let inserted = 0;
 
     for (const afterPos of targets) {
@@ -529,25 +536,25 @@
       if (findWrap(kindClass, afterPos)) continue;
 
       let id = pickIdFromAll(allIds, cursorKey);
-
-      // If no ID is currently free, try a purge (only occasionally) then try again
       if (!id) {
-        if (!canRecycle(kind)) {
-          debug('recycle-skip-cooldown', kindClass);
+        // 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;
         }
-        const extraKeepFrom = Math.max(1, keepFrom + PURGE_BUFFER_ITEMS);
-        const extraKeepTo = Math.min(items.length, keepTo - PURGE_BUFFER_ITEMS);
-        const purgedMore = purgeOutsideWindow(kindClass, extraKeepFrom, extraKeepTo);
-        debug('recycle-needed', kindClass, { recycled: purgedMore > 0, ids: idsCount });
-
-        // After a recycle attempt, stop this run and wait for next tick to stabilize DOM
-        softBlock(400);
+        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;
+      }
 
       observePlaceholder(id);
       inserted += 1;
@@ -559,9 +566,10 @@
   async function insertHeroAdEarly() {
     if (state.heroDoneForPage) return;
     const cfg = await fetchConfigOnce();
-    if (!cfg || cfg.excluded) return;
+    if (!cfg) { dbg('no-config'); return; }
+    if (cfg.excluded) { dbg('excluded'); return; }
 
-    initIds(cfg);
+    initPools(cfg);
 
     const kind = getKind();
     let items = [];
@@ -571,32 +579,31 @@
     let showFirst = false;
 
     if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
-      showFirst = normalizeBool(cfg.showFirstMessageAd);
-      if (!showFirst) return;
       items = getPostContainers();
       allIds = state.allPosts;
       cursorKey = 'curPosts';
       kindClass = 'ezoic-ad-message';
+      showFirst = normalizeBool(cfg.showFirstMessageAd);
     } else if (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
-      showFirst = normalizeBool(cfg.showFirstTopicAd);
-      if (!showFirst) return;
       items = getTopicItems();
       allIds = state.allTopics;
       cursorKey = 'curTopics';
       kindClass = 'ezoic-ad-between';
+      showFirst = normalizeBool(cfg.showFirstTopicAd);
     } else if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
-      showFirst = normalizeBool(cfg.showFirstCategoryAd);
-      if (!showFirst) return;
       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;
@@ -607,29 +614,33 @@
     if (!id) return;
 
     const wrap = insertAfter(el, id, kindClass, afterPos);
-    if (!wrap) return;
+    if (!wrap) {
+      return;
+    }
 
     state.heroDoneForPage = true;
     observePlaceholder(id);
   }
 
   async function runCore() {
-    if (isBlocked()) return;
+    if (isBlocked()) { dbg('blocked'); return; }
 
     patchShowAds();
 
     const cfg = await fetchConfigOnce();
-    if (!cfg || cfg.excluded) return;
-    initIds(cfg);
+    if (!cfg) { dbg('no-config'); return; }
+    if (cfg.excluded) { dbg('excluded'); return; }
+    initPools(cfg);
 
     const kind = getKind();
 
     if (kind === 'topic') {
       if (normalizeBool(cfg.enableMessageAds)) {
-        injectWindowed(
-          'topic',
+        const __items = getPostContainers();
+        pruneOrphanWraps('ezoic-ad-message', __items);
+        injectBetween(
           'ezoic-ad-message',
-          getPostContainers(),
+          __items,
           Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
           normalizeBool(cfg.showFirstMessageAd),
           state.allPosts,
@@ -638,10 +649,11 @@
       }
     } else if (kind === 'categoryTopics') {
       if (normalizeBool(cfg.enableBetweenAds)) {
-        injectWindowed(
-          'categoryTopics',
+        const __items = getTopicItems();
+        pruneOrphanWraps('ezoic-ad-between', __items);
+        injectBetween(
           'ezoic-ad-between',
-          getTopicItems(),
+          __items,
           Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
           normalizeBool(cfg.showFirstTopicAd),
           state.allTopics,
@@ -650,10 +662,11 @@
       }
     } else if (kind === 'categories') {
       if (normalizeBool(cfg.enableCategoryAds)) {
-        injectWindowed(
-          'categories',
+        const __items = getCategoryItems();
+        pruneOrphanWraps('ezoic-ad-categories', __items);
+        injectBetween(
           'ezoic-ad-categories',
-          getCategoryItems(),
+          __items,
           Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
           normalizeBool(cfg.showFirstCategoryAd),
           state.allCategories,
@@ -675,19 +688,14 @@
   }
 
   // ---------- observers / lifecycle ----------
+
   function cleanup() {
-    softBlock(2000);
+    blockedUntil = Date.now() + 1200;
 
     // remove all wrappers
     try {
-      withInternalDomChange(() => {
-        document.querySelectorAll(`.${WRAP_CLASS}`).forEach((el) => {
-          try {
-            const id = parseInt(el.getAttribute('data-ezoic-wrapid') || '', 10);
-            if (Number.isFinite(id) && id > 0) destroyPlaceholderId(id);
-          } catch (e) {}
-          try { el.remove(); } catch (e) {}
-        });
+      document.querySelectorAll(`.${WRAP_CLASS}`).forEach((el) => {
+        try { el.remove(); } catch (e) {}
       });
     } catch (e) {}
 
@@ -699,20 +707,18 @@
     state.curTopics = 0;
     state.curPosts = 0;
     state.curCategories = 0;
-
     state.lastShowById.clear();
+    try { state.usedOnce && state.usedOnce.clear(); } catch (e) {}
     state.heroDoneForPage = false;
-    state.lastRecycleAt.topic = 0;
-    state.lastRecycleAt.categoryTopics = 0;
-    state.lastRecycleAt.categories = 0;
+
+    // keep observers alive (MutationObserver will re-trigger after navigation)
   }
 
   function ensureDomObserver() {
     if (state.domObs) return;
     state.domObs = new MutationObserver(() => {
       if (state.internalDomChange > 0) return;
-      if (isBlocked()) return;
-      scheduleRun();
+      if (!isBlocked()) scheduleRun();
     });
     try {
       state.domObs.observe(document.body, { childList: true, subtree: true });
@@ -730,7 +736,7 @@
 
     $(window).on('action:ajaxify.end.ezoicInfinite', () => {
       state.pageKey = getPageKey();
-      softBlock(500);
+      blockedUntil = 0;
 
       warmUpNetwork();
       patchShowAds();
@@ -764,6 +770,7 @@
   }
 
   // ---------- boot ----------
+
   state.pageKey = getPageKey();
   warmUpNetwork();
   patchShowAds();
@@ -774,7 +781,7 @@
   bindScroll();
 
   // First paint: try hero + run
-  softBlock(300);
+  blockedUntil = 0;
   insertHeroAdEarly().catch(() => {});
   scheduleRun();
-})();
+})();

package/public/style.css

@@ -23,11 +23,12 @@
 
 /* Collapse empty ad blocks (prevents "holes" when an ad doesn't fill or gets destroyed) */
 .ezoic-ad.is-empty {
-  display: none !important;
+  display: block !important;
   margin: 0 !important;
   padding: 0 !important;
   height: 0 !important;
   min-height: 0 !important;
+  overflow: hidden !important;
 }
 
 .ezoic-ad {