nodebb-plugin-ezoic-infinite 1.5.27 → 1.5.28

package/package.json

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

package/public/client.js

@@ -13,23 +13,27 @@
   // 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 lists (never consumed) + cursors for round-robin reuse
+    // Full ID lists + cursors (round-robin)
     allTopics: [],
     allPosts: [],
     allCategories: [],
@@ -39,11 +43,6 @@
 
     // 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,
@@ -52,22 +51,28 @@
 
     // hero
     heroDoneForPage: false,
-  };
 
-  const insertingIds = new Set();
+    // internal DOM changes (to ignore our own mutations)
+    internalDomChange: 0,
 
-  // 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) {}
+    // 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) {}
   }
 
   // ---------- small utils ----------
-
   function normalizeBool(v) {
     return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
@@ -94,6 +99,16 @@
     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;
@@ -138,8 +153,12 @@
     });
   }
 
-  // ---------- warm-up & patching ----------
+  function withInternalDomChange(fn) {
+    state.internalDomChange++;
+    try { return fn(); } finally { state.internalDomChange--; }
+  }
 
+  // ---------- warm-up & patching ----------
   const _warmLinksDone = new Set();
   function warmUpNetwork() {
     try {
@@ -206,29 +225,7 @@
     }
   }
 
-    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 ----------
-
+  // ---------- config & ids ----------
   async function fetchConfigOnce() {
     if (state.cfg) return state.cfg;
     try {
@@ -241,7 +238,7 @@ function withInternalDomChange(fn) {
     }
   }
 
-  function initPools(cfg) {
+  function initIds(cfg) {
     if (!cfg) return;
     if (state.allTopics.length === 0) state.allTopics = parsePool(cfg.placeholderIds);
     if (state.allPosts.length === 0) state.allPosts = parsePool(cfg.messagePlaceholderIds);
@@ -249,7 +246,6 @@ function withInternalDomChange(fn) {
   }
 
   // ---------- insertion primitives ----------
-
   function isAdjacentAd(target) {
     if (!target) return false;
     const next = target.nextElementSibling;
@@ -261,8 +257,9 @@ function withInternalDomChange(fn) {
 
   function buildWrap(id, kindClass, afterPos) {
     const wrap = document.createElement('div');
-    wrap.className = `${WRAP_CLASS} ${kindClass}`;
+    wrap.className = `${WRAP_CLASS} ${kindClass} is-empty`;
     wrap.setAttribute('data-ezoic-after', String(afterPos));
+    wrap.setAttribute('data-ezoic-wrapid', String(id));
     wrap.style.width = '100%';
 
     const ph = document.createElement('div');
@@ -280,26 +277,68 @@ function withInternalDomChange(fn) {
   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 {
+    return withInternalDomChange(() => {
       const wrap = buildWrap(id, kindClass, afterPos);
       target.insertAdjacentElement('afterend', wrap);
       return wrap;
-    } finally {
-      insertingIds.delete(id);
-    }
+    });
+  }
+
+  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;
   }
 
   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
+    // Try at most n IDs to find one not currently present
     for (let tries = 0; tries < n; tries++) {
       const idx = state[cursorKey] % n;
       state[cursorKey] = (state[cursorKey] + 1) % n;
@@ -307,38 +346,24 @@ function withInternalDomChange(fn) {
       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;
-
-      // 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
+  function markEmptyLater(id) {
+    // Collapse empty blocks if ad never fills
+    window.setTimeout(() => {
       try {
-        const ph = victim.querySelector && victim.querySelector(`[id^="${PLACEHOLDER_PREFIX}"]`);
-        if (ph && state.io) state.io.unobserve(ph);
+        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');
       } catch (e) {}
-
-      victim.remove();
-      return true;
-    } catch (e) {
-      return false;
-    }
+    }, 1800);
   }
 
   function showAd(id) {
@@ -348,36 +373,27 @@ function withInternalDomChange(fn) {
     const last = state.lastShowById.get(id) || 0;
     if (now - last < 1500) return; // basic throttle
 
-    // Defer one frame so the placeholder is definitely in DOM after insertion/recycle
-    requestAnimationFrame(() => {
+    const doShow = () => {
       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 < 1200) return;
-      state.lastShowById.set(id, now2);
+      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) {}
 
       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') {
-          doShow();
+          ez.showAds(id);
+          markEmptyLater(id);
           return;
         }
 
@@ -390,25 +406,19 @@ function withInternalDomChange(fn) {
               if (isBlocked()) return;
               const el = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
               if (!el || !el.isConnected) return;
-              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) {}
+              window.ezstandalone.showAds(id);
+              markEmptyLater(id);
             } 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 {
@@ -442,22 +452,72 @@ function withInternalDomChange(fn) {
     } catch (e) {}
   }
 
-  // ---------- insertion logic ----------
+  // ---------- 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 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);
+  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;
     }
-    return Array.from(new Set(out)).sort((a, b) => a - b);
+
+    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];
+  }
+
+  function computeTargetsInRange(fromPos, toPos, 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;
   }
 
-  function injectBetween(kindClass, items, interval, showFirst, allIds, cursorKey) {
+  function injectWindowed(kind, kindClass, items, interval, showFirst, allIds, cursorKey) {
     if (!items.length) return 0;
 
-    const targets = computeTargets(items.length, interval, showFirst);
+    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);
     let inserted = 0;
 
     for (const afterPos of targets) {
@@ -469,25 +529,25 @@ function withInternalDomChange(fn) {
       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) {
-        // 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);
+        if (!canRecycle(kind)) {
+          debug('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.
+        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);
         break;
       }
+
       const wrap = insertAfter(el, id, kindClass, afterPos);
-      if (!wrap) {
-        continue;
-      }
+      if (!wrap) continue;
 
       observePlaceholder(id);
       inserted += 1;
@@ -499,10 +559,9 @@ function withInternalDomChange(fn) {
   async function insertHeroAdEarly() {
     if (state.heroDoneForPage) return;
     const cfg = await fetchConfigOnce();
-    if (!cfg) { dbg('no-config'); return; }
-    if (cfg.excluded) { dbg('excluded'); return; }
+    if (!cfg || cfg.excluded) return;
 
-    initPools(cfg);
+    initIds(cfg);
 
     const kind = getKind();
     let items = [];
@@ -512,31 +571,32 @@ function withInternalDomChange(fn) {
     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;
@@ -547,29 +607,27 @@ function withInternalDomChange(fn) {
     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()) { dbg('blocked'); return; }
+    if (isBlocked()) return;
 
     patchShowAds();
 
     const cfg = await fetchConfigOnce();
-    if (!cfg) { dbg('no-config'); return; }
-    if (cfg.excluded) { dbg('excluded'); return; }
-    initPools(cfg);
+    if (!cfg || cfg.excluded) return;
+    initIds(cfg);
 
     const kind = getKind();
 
     if (kind === 'topic') {
       if (normalizeBool(cfg.enableMessageAds)) {
-        injectBetween(
+        injectWindowed(
+          'topic',
           'ezoic-ad-message',
           getPostContainers(),
           Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
@@ -580,7 +638,8 @@ function withInternalDomChange(fn) {
       }
     } else if (kind === 'categoryTopics') {
       if (normalizeBool(cfg.enableBetweenAds)) {
-        injectBetween(
+        injectWindowed(
+          'categoryTopics',
           'ezoic-ad-between',
           getTopicItems(),
           Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
@@ -591,7 +650,8 @@ function withInternalDomChange(fn) {
       }
     } else if (kind === 'categories') {
       if (normalizeBool(cfg.enableCategoryAds)) {
-        injectBetween(
+        injectWindowed(
+          'categories',
           'ezoic-ad-categories',
           getCategoryItems(),
           Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
@@ -615,14 +675,19 @@ function withInternalDomChange(fn) {
   }
 
   // ---------- observers / lifecycle ----------
-
   function cleanup() {
-    blockedUntil = Date.now() + 1200;
+    softBlock(2000);
 
     // remove all wrappers
     try {
-      document.querySelectorAll(`.${WRAP_CLASS}`).forEach((el) => {
-        try { el.remove(); } catch (e) {}
+      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) {}
+        });
       });
     } catch (e) {}
 
@@ -634,18 +699,20 @@ function withInternalDomChange(fn) {
     state.curTopics = 0;
     state.curPosts = 0;
     state.curCategories = 0;
+
     state.lastShowById.clear();
-    try { state.usedOnce && state.usedOnce.clear(); } catch (e) {}
     state.heroDoneForPage = false;
-
-    // keep observers alive (MutationObserver will re-trigger after navigation)
+    state.lastRecycleAt.topic = 0;
+    state.lastRecycleAt.categoryTopics = 0;
+    state.lastRecycleAt.categories = 0;
   }
 
   function ensureDomObserver() {
     if (state.domObs) return;
     state.domObs = new MutationObserver(() => {
       if (state.internalDomChange > 0) return;
-      if (!isBlocked()) scheduleRun();
+      if (isBlocked()) return;
+      scheduleRun();
     });
     try {
       state.domObs.observe(document.body, { childList: true, subtree: true });
@@ -663,7 +730,7 @@ function withInternalDomChange(fn) {
 
     $(window).on('action:ajaxify.end.ezoicInfinite', () => {
       state.pageKey = getPageKey();
-      blockedUntil = 0;
+      softBlock(500);
 
       warmUpNetwork();
       patchShowAds();
@@ -697,7 +764,6 @@ function withInternalDomChange(fn) {
   }
 
   // ---------- boot ----------
-
   state.pageKey = getPageKey();
   warmUpNetwork();
   patchShowAds();
@@ -708,7 +774,7 @@ function withInternalDomChange(fn) {
   bindScroll();
 
   // First paint: try hero + run
-  blockedUntil = 0;
+  softBlock(300);
   insertHeroAdEarly().catch(() => {});
   scheduleRun();
-})();
+})();

package/public/style.css

@@ -19,3 +19,21 @@
   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: none !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  height: 0 !important;
+  min-height: 0 !important;
+}
+
+.ezoic-ad {
+  min-height: 0 !important;
+}
+
+.ezoic-ad > [id^="ezoic-pub-ad-placeholder-"] {
+  min-height: 0 !important;
+}