nodebb-plugin-ezoic-infinite 1.8.66 → 1.8.67

package/public/client.js

@@ -1,12 +1,11 @@
 /**
- * NodeBB Ezoic Infinite Ads — client.js v2.2.0
+ * NodeBB Ezoic Infinite Ads — client.js v2.4.0
  *
- * Based on working v2-fixed with targeted fixes:
- * - Ezoic API: showAds() + destroyPlaceholders() only (per official docs)
- * - cleanup(): destroyAll() before DOM removal, only on real page change
- * - Recycling: conservative threshold (-3vh), age/inflight guards
- * - aria-hidden: MutationObserver protection
- * - Empty check: more conservative timing and GPT slot awareness
+ * Architecture: proven v50 core + targeted improvements.
+ * Ezoic API: showAds() + destroyPlaceholders() per official docs.
+ * Key features: O(1) recycle via wrapsByClass, MutationObserver fill detect,
+ * conservative empty check, aria-hidden + TCF protection, retry boot for
+ * Cloudflare/async timing.
  */
 (function nbbEzoicInfinite() {
   'use strict';
@@ -24,30 +23,25 @@
   };
 
   const TIMING = {
-    EMPTY_CHECK_EARLY_MS: 30_000,
-    EMPTY_CHECK_LATE_MS:  60_000,
-    MIN_PRUNE_AGE_MS:      8_000,
-    SHOW_THROTTLE_MS:        900,
-    BURST_COOLDOWN_MS:       200,
-    BLOCK_DURATION_MS:     1_500,
-    SHOW_TIMEOUT_MS:       7_000,
-    SHOW_RELEASE_MS:         700,
-    BATCH_FLUSH_MS:           80,
-    RECYCLE_DELAY_MS:        450,
+    EMPTY_CHECK_MS_1:  30_000,
+    EMPTY_CHECK_MS_2:  60_000,
+    MIN_PRUNE_AGE_MS:   8_000,
+    RECYCLE_MIN_AGE_MS: 5_000,
+    SHOW_THROTTLE_MS:     900,
+    BURST_COOLDOWN_MS:    200,
+    BLOCK_DURATION_MS:  1_500,
+    SHOW_TIMEOUT_MS:    7_000,
+    SHOW_RELEASE_MS:      700,
+    RECYCLE_DELAY_MS:     450,
   };
 
-  const LIMITS = {
-    MAX_INSERTS_RUN: 6,
-    MAX_INFLIGHT:    4,
-    BATCH_SIZE:      3,
-    MAX_BURST_STEPS: 8,
-    BURST_WINDOW_MS: 2_000,
-  };
+  const MAX_INSERTS_RUN = 6;
+  const MAX_INFLIGHT    = 4;
+  const MAX_BURST_STEPS = 8;
+  const BURST_WINDOW_MS = 2_000;
 
-  const IO_MARGIN = {
-    DESKTOP: '2500px 0px 2500px 0px',
-    MOBILE:  '3500px 0px 3500px 0px',
-  };
+  const IO_MARGIN_DESKTOP = '2500px 0px 2500px 0px';
+  const IO_MARGIN_MOBILE  = '3500px 0px 3500px 0px';
 
   const SEL = {
     post:     '[component="post"][data-pid]',
@@ -62,103 +56,78 @@
   };
 
   const FILL_SEL = 'iframe, ins, img, video, [data-google-container-id], div[id$="__container__"]';
-  const RECYCLE_MIN_AGE_MS = 5_000;
 
   // ── Utility ────────────────────────────────────────────────────────────────
 
   const now      = () => Date.now();
   const isMobile = () => window.innerWidth < 768;
   const normBool = v  => v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
-
-  function isFilled(node) {
-    return node?.querySelector?.(FILL_SEL) != null;
-  }
-
-  function isPlaceholderUsed(ph) {
-    if (!ph?.isConnected) return false;
-    return ph.querySelector('ins.adsbygoogle, iframe, [data-google-container-id], div[id$="__container__"]') != null;
-  }
+  const isFilled = n  => !!(n?.querySelector?.(FILL_SEL));
 
   function parseIds(raw) {
-    const out = [];
-    const seen = new Set();
-    for (const line of String(raw || '').split(/[\r\n,\s]+/)) {
-      const n = parseInt(line, 10);
-      if (n > 0 && Number.isFinite(n) && !seen.has(n)) {
-        seen.add(n);
-        out.push(n);
-      }
+    const out = [], seen = new Set();
+    for (const v of String(raw || '').split(/[\r\n,\s]+/)) {
+      const n = parseInt(v, 10);
+      if (n > 0 && Number.isFinite(n) && !seen.has(n)) { seen.add(n); out.push(n); }
     }
     return out;
   }
 
   // ── State ──────────────────────────────────────────────────────────────────
 
-  const state = {
-    pageKey:    null,
-    kind:       null,
-    cfg:        null,
-
-    poolsReady: false,
-    pools:      { topics: [], posts: [], categories: [] },
-    cursors:    { topics: 0,  posts: 0,  categories: 0  },
-
-    mountedIds: new Set(),
-    phState:    new Map(),  // id → 'new' | 'show-queued' | 'shown' | 'destroyed'
-    lastShow:   new Map(),  // id → timestamp
-
+  const S = {
+    pageKey:      null,
+    kind:         null,
+    cfg:          null,
+    poolsReady:   false,
+    pools:        { topics: [], posts: [], categories: [] },
+    cursors:      { topics: 0,  posts: 0,  categories: 0  },
+    mountedIds:   new Set(),
+    lastShow:     new Map(),
     wrapByKey:    new Map(),
     wrapsByClass: new Map(),
-
-    io:     null,
-    domObs: null,
-
+    io:           null,
+    domObs:       null,
     mutGuard:     0,
     blockedUntil: 0,
-
-    inflight:   0,
-    pending:    [],
-    pendingSet: new Set(),
-
-    runQueued:     false,
-    burstActive:   false,
+    inflight:     0,
+    pending:      [],
+    pendingSet:   new Set(),
+    runQueued:    false,
+    burstActive:  false,
     burstDeadline: 0,
-    burstCount:    0,
-    lastBurstTs:   0,
-    firstShown:    false,
+    burstCount:   0,
+    lastBurstTs:  0,
   };
 
-  const isBlocked = () => now() < state.blockedUntil;
+  const isBlocked = () => now() < S.blockedUntil;
 
   function mutate(fn) {
-    state.mutGuard++;
-    try { fn(); } finally { state.mutGuard--; }
+    S.mutGuard++;
+    try { fn(); } finally { S.mutGuard--; }
   }
 
   // ── Config ─────────────────────────────────────────────────────────────────
 
   async function fetchConfig() {
-    if (state.cfg) return state.cfg;
+    if (S.cfg) return S.cfg;
     try {
       const inline = window.__nbbEzoicCfg;
-      if (inline && typeof inline === 'object') {
-        state.cfg = inline;
-        return state.cfg;
-      }
+      if (inline && typeof inline === 'object') { S.cfg = inline; return S.cfg; }
     } catch (_) {}
     try {
       const r = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
-      if (r.ok) state.cfg = await r.json();
+      if (r.ok) S.cfg = await r.json();
     } catch (_) {}
-    return state.cfg;
+    return S.cfg;
   }
 
   function initPools(cfg) {
-    if (state.poolsReady) return;
-    state.pools.topics     = parseIds(cfg.placeholderIds);
-    state.pools.posts      = parseIds(cfg.messagePlaceholderIds);
-    state.pools.categories = parseIds(cfg.categoryPlaceholderIds);
-    state.poolsReady = true;
+    if (S.poolsReady) return;
+    S.pools.topics     = parseIds(cfg.placeholderIds);
+    S.pools.posts      = parseIds(cfg.messagePlaceholderIds);
+    S.pools.categories = parseIds(cfg.categoryPlaceholderIds);
+    S.poolsReady = true;
   }
 
   // ── Page identity ──────────────────────────────────────────────────────────
@@ -184,7 +153,7 @@
   }
 
   function getKind() {
-    return state.kind || (state.kind = detectKind());
+    return S.kind || (S.kind = detectKind());
   }
 
   // ── DOM queries ────────────────────────────────────────────────────────────
@@ -204,8 +173,8 @@
     return out;
   }
 
-  function getTopics()     { return Array.from(document.querySelectorAll(SEL.topic)); }
-  function getCategories() { return Array.from(document.querySelectorAll(SEL.category)); }
+  const getTopics     = () => Array.from(document.querySelectorAll(SEL.topic));
+  const getCategories = () => Array.from(document.querySelectorAll(SEL.category));
 
   // ── Anchor keys & wrap registry ────────────────────────────────────────────
 
@@ -226,60 +195,43 @@
   const anchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
 
   function findWrap(key) {
-    const w = state.wrapByKey.get(key);
+    const w = S.wrapByKey.get(key);
     return w?.isConnected ? w : null;
   }
 
   function getWrapSet(klass) {
-    let set = state.wrapsByClass.get(klass);
-    if (!set) { set = new Set(); state.wrapsByClass.set(klass, set); }
+    let set = S.wrapsByClass.get(klass);
+    if (!set) { set = new Set(); S.wrapsByClass.set(klass, set); }
     return set;
   }
 
-  // ── GC disconnected wraps (NodeBB virtualization) ──────────────────────────
+  // ── GC disconnected wraps ──────────────────────────────────────────────────
 
   function gcDisconnectedWraps() {
-    for (const [key, w] of Array.from(state.wrapByKey.entries())) {
-      if (!w?.isConnected) state.wrapByKey.delete(key);
+    for (const [key, w] of Array.from(S.wrapByKey)) {
+      if (!w?.isConnected) S.wrapByKey.delete(key);
     }
-    for (const [klass, set] of Array.from(state.wrapsByClass.entries())) {
+    for (const [klass, set] of Array.from(S.wrapsByClass)) {
       for (const w of Array.from(set)) {
         if (w?.isConnected) continue;
         set.delete(w);
-        try {
-          const id = parseInt(w.getAttribute(ATTR.WRAPID), 10);
-          if (Number.isFinite(id)) {
-            state.mountedIds.delete(id);
-            state.phState.delete(id);
-            state.lastShow.delete(id);
-          }
-        } catch (_) {}
-      }
-      if (!set.size) state.wrapsByClass.delete(klass);
-    }
-    try {
-      const live = new Set();
-      for (const w of document.querySelectorAll(`.${WRAP_CLASS}`)) {
-        const id = parseInt(w.getAttribute(ATTR.WRAPID) || '0', 10);
-        if (id > 0) live.add(id);
-      }
-      for (const id of Array.from(state.mountedIds)) {
-        if (!live.has(id)) {
-          state.mountedIds.delete(id);
-          state.phState.delete(id);
-          state.lastShow.delete(id);
+        const id = parseInt(w.getAttribute?.(ATTR.WRAPID), 10);
+        if (Number.isFinite(id)) {
+          S.mountedIds.delete(id);
+          S.lastShow.delete(id);
         }
       }
-    } catch (_) {}
+      if (!set.size) S.wrapsByClass.delete(klass);
+    }
   }
 
-  // ── Wrap lifecycle detection ───────────────────────────────────────────────
+  // ── Wrap lifecycle ─────────────────────────────────────────────────────────
 
   function wrapIsLive(wrap) {
     if (!wrap?.classList?.contains(WRAP_CLASS)) return false;
     const key = wrap.getAttribute(ATTR.ANCHOR);
     if (!key) return false;
-    if (state.wrapByKey.get(key) === wrap) return wrap.isConnected;
+    if (S.wrapByKey.get(key) === wrap) return wrap.isConnected;
     const colonIdx = key.indexOf(':');
     const klass    = key.slice(0, colonIdx);
     const anchorId = key.slice(colonIdx + 1);
@@ -299,9 +251,7 @@
     } catch (_) { return false; }
   }
 
-  function adjacentWrap(el) {
-    return wrapIsLive(el.nextElementSibling) || wrapIsLive(el.previousElementSibling);
-  }
+  const adjacentWrap = el => wrapIsLive(el.nextElementSibling) || wrapIsLive(el.previousElementSibling);
 
   // ── Fill detection ─────────────────────────────────────────────────────────
 
@@ -310,14 +260,12 @@
     const ph = wrap.querySelector(`[id^="${PH_PREFIX}"]`);
     if (!ph || !isFilled(ph)) return false;
     wrap.classList.remove('is-empty');
-    const id = parseInt(wrap.getAttribute(ATTR.WRAPID) || '0', 10);
-    if (id > 0) state.phState.set(id, 'shown');
     return true;
   }
 
   function scheduleUncollapseChecks(wrap) {
     if (!wrap) return;
-    for (const ms of [500, 1500, 3000, 7000, 15000]) {
+    for (const ms of [500, 3000, 10000]) {
       setTimeout(() => { try { clearEmptyIfFilled(wrap); } catch (_) {} }, ms);
     }
   }
@@ -325,45 +273,36 @@
   // ── Pool management ────────────────────────────────────────────────────────
 
   function pickId(poolKey) {
-    const pool = state.pools[poolKey];
+    const pool = S.pools[poolKey];
     if (!pool.length) return null;
     for (let t = 0; t < pool.length; t++) {
-      const idx = state.cursors[poolKey] % pool.length;
-      state.cursors[poolKey] = (state.cursors[poolKey] + 1) % pool.length;
+      const idx = S.cursors[poolKey] % pool.length;
+      S.cursors[poolKey] = (S.cursors[poolKey] + 1) % pool.length;
       const id = pool[idx];
-      if (!state.mountedIds.has(id)) return id;
+      if (!S.mountedIds.has(id)) return id;
     }
     return null;
   }
 
   // ── Recycling ──────────────────────────────────────────────────────────────
-  //
-  // Per Ezoic docs: destroyPlaceholders(id) → remove old HTML →
-  // recreate fresh placeholder → showAds(id).
 
   function recycleWrap(klass, targetEl, newKey) {
     const ez = window.ezstandalone;
     if (typeof ez?.destroyPlaceholders !== 'function' ||
         typeof ez?.showAds             !== 'function') return null;
 
-    const vh = window.innerHeight || 800;
-    const threshold = -(3 * vh);
+    const threshold = -(3 * (window.innerHeight || 800));
     const t = now();
     let bestEmpty = null, bestEmptyY = Infinity;
     let bestFull  = null, bestFullY  = Infinity;
 
-    const wraps = state.wrapsByClass.get(klass);
+    const wraps = S.wrapsByClass.get(klass);
     if (!wraps) return null;
 
     for (const wrap of wraps) {
       try {
-        // Skip young wraps (ad might still be loading)
         const created = parseInt(wrap.getAttribute(ATTR.CREATED) || '0', 10);
-        if (t - created < RECYCLE_MIN_AGE_MS) continue;
-        // Skip wraps with inflight showAds
-        const wid = parseInt(wrap.getAttribute(ATTR.WRAPID), 10);
-        if (wid > 0 && state.phState.get(wid) === 'show-queued') continue;
-
+        if (t - created < TIMING.RECYCLE_MIN_AGE_MS) continue;
         const bottom = wrap.getBoundingClientRect().bottom;
         if (bottom > threshold) continue;
         if (!isFilled(wrap)) {
@@ -376,56 +315,37 @@
 
     const best = bestEmpty ?? bestFull;
     if (!best) return null;
-
     const id = parseInt(best.getAttribute(ATTR.WRAPID), 10);
     if (!Number.isFinite(id)) return null;
-
     const oldKey = best.getAttribute(ATTR.ANCHOR);
 
-    // Unobserve before moving
     try {
       const ph = best.querySelector(`#${PH_PREFIX}${id}`);
-      if (ph) state.io?.unobserve(ph);
+      if (ph) S.io?.unobserve(ph);
     } catch (_) {}
 
-    // Ezoic recycle: destroy → new DOM → showAds
     const doRecycle = () => {
-      state.phState.set(id, 'destroyed');
       try { ez.destroyPlaceholders(id); } catch (_) {}
-
       setTimeout(() => {
-        // Recreate fresh placeholder DOM at new position
         mutate(() => {
           best.setAttribute(ATTR.ANCHOR,  newKey);
           best.setAttribute(ATTR.CREATED, String(now()));
           best.setAttribute(ATTR.SHOWN,   '0');
           best.classList.remove('is-empty');
           best.replaceChildren();
-
           const fresh = document.createElement('div');
           fresh.id = `${PH_PREFIX}${id}`;
           fresh.setAttribute('data-ezoic-id', String(id));
-          fresh.style.minHeight = '1px';
           best.appendChild(fresh);
           targetEl.insertAdjacentElement('afterend', best);
         });
-
-        if (oldKey && state.wrapByKey.get(oldKey) === best) state.wrapByKey.delete(oldKey);
-        state.wrapByKey.set(newKey, best);
-
-        // Re-show after DOM is settled
-        setTimeout(() => {
-          observePlaceholder(id);
-          state.phState.set(id, 'new');
-          enqueueShow(id);
-        }, TIMING.RECYCLE_DELAY_MS);
+        if (oldKey && S.wrapByKey.get(oldKey) === best) S.wrapByKey.delete(oldKey);
+        S.wrapByKey.set(newKey, best);
+        setTimeout(() => { observePh(id); enqueueShow(id); }, TIMING.RECYCLE_DELAY_MS);
       }, TIMING.RECYCLE_DELAY_MS);
     };
 
-    try {
-      (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doRecycle) : doRecycle();
-    } catch (_) {}
-
+    try { (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doRecycle) : doRecycle(); } catch (_) {}
     return { id, wrap: best };
   }
 
@@ -439,11 +359,9 @@
     w.setAttribute(ATTR.CREATED, String(now()));
     w.setAttribute(ATTR.SHOWN,   '0');
     w.style.cssText = 'width:100%;display:block';
-
     const ph = document.createElement('div');
     ph.id = `${PH_PREFIX}${id}`;
     ph.setAttribute('data-ezoic-id', String(id));
-    ph.style.minHeight = '1px';
     w.appendChild(ph);
     return w;
   }
@@ -451,15 +369,12 @@
   function insertAfter(el, id, klass, key) {
     if (!el?.insertAdjacentElement) return null;
     if (findWrap(key)) return null;
-    if (state.mountedIds.has(id)) return null;
-    const existing = document.getElementById(`${PH_PREFIX}${id}`);
-    if (existing?.isConnected) return null;
-
+    if (S.mountedIds.has(id)) return null;
+    if (document.getElementById(`${PH_PREFIX}${id}`)?.isConnected) return null;
     const w = makeWrap(id, klass, key);
     mutate(() => el.insertAdjacentElement('afterend', w));
-    state.mountedIds.add(id);
-    state.phState.set(id, 'new');
-    state.wrapByKey.set(key, w);
+    S.mountedIds.add(id);
+    S.wrapByKey.set(key, w);
     getWrapSet(klass).add(w);
     return w;
   }
@@ -467,17 +382,17 @@
   function dropWrap(w) {
     try {
       const ph = w.querySelector(`[id^="${PH_PREFIX}"]`);
-      if (ph instanceof Element) state.io?.unobserve(ph);
+      if (ph instanceof Element) S.io?.unobserve(ph);
       const id = parseInt(w.getAttribute(ATTR.WRAPID), 10);
       if (Number.isFinite(id)) {
-        state.mountedIds.delete(id);
-        state.phState.delete(id);
+        S.mountedIds.delete(id);
+        S.lastShow.delete(id);
       }
       const key = w.getAttribute(ATTR.ANCHOR);
-      if (key && state.wrapByKey.get(key) === w) state.wrapByKey.delete(key);
+      if (key && S.wrapByKey.get(key) === w) S.wrapByKey.delete(key);
       for (const cls of w.classList) {
         if (cls !== WRAP_CLASS && cls.startsWith('ezoic-ad-')) {
-          state.wrapsByClass.get(cls)?.delete(w);
+          S.wrapsByClass.get(cls)?.delete(w);
           break;
         }
       }
@@ -490,24 +405,20 @@
   function pruneOrphansBetween() {
     const klass = 'ezoic-ad-between';
     const cfg   = KIND[klass];
-    const wraps = state.wrapsByClass.get(klass);
+    const wraps = S.wrapsByClass.get(klass);
     if (!wraps?.size) return;
-
     const liveAnchors = new Set();
     for (const el of document.querySelectorAll(`${cfg.baseTag}[${cfg.anchorAttr}]`)) {
       const v = el.getAttribute(cfg.anchorAttr);
       if (v) liveAnchors.add(v);
     }
-
     const t = now();
-    for (const w of wraps) {
+    for (const w of Array.from(wraps)) {
       const created = parseInt(w.getAttribute(ATTR.CREATED) || '0', 10);
       if (t - created < TIMING.MIN_PRUNE_AGE_MS) continue;
       const key = w.getAttribute(ATTR.ANCHOR) ?? '';
       const sid = key.slice(klass.length + 1);
-      if (!sid || !liveAnchors.has(sid)) {
-        mutate(() => dropWrap(w));
-      }
+      if (!sid || !liveAnchors.has(sid)) mutate(() => dropWrap(w));
     }
   }
 
@@ -531,29 +442,20 @@
   function injectBetween(klass, items, interval, showFirst, poolKey) {
     if (!items.length) return 0;
     let inserted = 0;
-
     for (const el of items) {
-      if (inserted >= LIMITS.MAX_INSERTS_RUN) break;
+      if (inserted >= MAX_INSERTS_RUN) break;
       if (!el?.isConnected) continue;
-
       const ord = ordinal(klass, el);
       if (!(showFirst && ord === 0) && (ord + 1) % interval !== 0) continue;
       if (adjacentWrap(el)) continue;
-
       const key = anchorKey(klass, el);
       if (findWrap(key)) continue;
-
       const id = pickId(poolKey);
       if (id) {
         const w = insertAfter(el, id, klass, key);
-        if (w) {
-          observePlaceholder(id);
-          if (!state.firstShown) { state.firstShown = true; enqueueShow(id); }
-          inserted++;
-        }
+        if (w) { observePh(id); inserted++; }
       } else {
-        const recycled = recycleWrap(klass, el, key);
-        if (!recycled) break;
+        if (!recycleWrap(klass, el, key)) break;
         inserted++;
       }
     }
@@ -563,69 +465,58 @@
   // ── IntersectionObserver ───────────────────────────────────────────────────
 
   function getIO() {
-    if (state.io) return state.io;
+    if (S.io) return S.io;
     try {
-      state.io = new IntersectionObserver(entries => {
-        for (const entry of entries) {
-          if (!entry.isIntersecting) continue;
-          if (entry.target instanceof Element) state.io?.unobserve(entry.target);
-          const id = parseInt(entry.target.getAttribute('data-ezoic-id'), 10);
+      S.io = new IntersectionObserver(entries => {
+        for (const e of entries) {
+          if (!e.isIntersecting) continue;
+          if (e.target instanceof Element) S.io?.unobserve(e.target);
+          const id = parseInt(e.target.getAttribute('data-ezoic-id'), 10);
           if (id > 0) enqueueShow(id);
         }
       }, {
         root: null,
-        rootMargin: isMobile() ? IO_MARGIN.MOBILE : IO_MARGIN.DESKTOP,
+        rootMargin: isMobile() ? IO_MARGIN_MOBILE : IO_MARGIN_DESKTOP,
         threshold: 0,
       });
-    } catch (_) { state.io = null; }
-    return state.io;
+    } catch (_) { S.io = null; }
+    return S.io;
   }
 
-  function observePlaceholder(id) {
+  function observePh(id) {
     const ph = document.getElementById(`${PH_PREFIX}${id}`);
-    if (ph?.isConnected) {
-      try { getIO()?.observe(ph); } catch (_) {}
-    }
+    if (ph?.isConnected) try { getIO()?.observe(ph); } catch (_) {}
   }
 
   // ── Show queue ─────────────────────────────────────────────────────────────
 
   function enqueueShow(id) {
     if (!id || isBlocked()) return;
-    const st = state.phState.get(id);
-    if (st === 'show-queued' || st === 'shown') return;
-    if (now() - (state.lastShow.get(id) ?? 0) < TIMING.SHOW_THROTTLE_MS) return;
-
-    if (state.inflight >= LIMITS.MAX_INFLIGHT) {
-      if (!state.pendingSet.has(id)) {
-        state.pending.push(id);
-        state.pendingSet.add(id);
-        state.phState.set(id, 'show-queued');
-      }
+    if (now() - (S.lastShow.get(id) ?? 0) < TIMING.SHOW_THROTTLE_MS) return;
+    if (S.inflight >= MAX_INFLIGHT) {
+      if (!S.pendingSet.has(id)) { S.pending.push(id); S.pendingSet.add(id); }
       return;
     }
-    state.phState.set(id, 'show-queued');
     startShow(id);
   }
 
   function drainQueue() {
     if (isBlocked()) return;
-    while (state.inflight < LIMITS.MAX_INFLIGHT && state.pending.length) {
-      const id = state.pending.shift();
-      state.pendingSet.delete(id);
+    while (S.inflight < MAX_INFLIGHT && S.pending.length) {
+      const id = S.pending.shift();
+      S.pendingSet.delete(id);
       startShow(id);
     }
   }
 
   function startShow(id) {
     if (!id || isBlocked()) return;
-    state.inflight++;
-
-    let released = false;
+    S.inflight++;
+    let done = false;
     const release = () => {
-      if (released) return;
-      released = true;
-      state.inflight = Math.max(0, state.inflight - 1);
+      if (done) return;
+      done = true;
+      S.inflight = Math.max(0, S.inflight - 1);
       drainQueue();
     };
     const timer = setTimeout(release, TIMING.SHOW_TIMEOUT_MS);
@@ -633,52 +524,29 @@
     requestAnimationFrame(() => {
       try {
         if (isBlocked()) { clearTimeout(timer); return release(); }
-
         const ph = document.getElementById(`${PH_PREFIX}${id}`);
-        if (!ph?.isConnected) {
-          state.phState.delete(id);
-          clearTimeout(timer);
-          return release();
-        }
-
-        if (isFilled(ph) || isPlaceholderUsed(ph)) {
-          state.phState.set(id, 'shown');
-          clearTimeout(timer);
-          return release();
-        }
-
+        if (!ph?.isConnected || isFilled(ph)) { clearTimeout(timer); return release(); }
         const t = now();
-        if (t - (state.lastShow.get(id) ?? 0) < TIMING.SHOW_THROTTLE_MS) {
-          clearTimeout(timer);
-          return release();
-        }
-        state.lastShow.set(id, t);
-
-        try { ph.closest(`.${WRAP_CLASS}`)?.setAttribute(ATTR.SHOWN, String(t)); } catch (_) {}
-        state.phState.set(id, 'shown');
+        if (t - (S.lastShow.get(id) ?? 0) < TIMING.SHOW_THROTTLE_MS) { clearTimeout(timer); return release(); }
+        S.lastShow.set(id, t);
+        const wrap = ph.closest(`.${WRAP_CLASS}`);
+        try { wrap?.setAttribute(ATTR.SHOWN, String(t)); } catch (_) {}
 
         window.ezstandalone = window.ezstandalone || {};
         const ez = window.ezstandalone;
-
         const doShow = () => {
-          const wrap = ph.closest(`.${WRAP_CLASS}`);
           try { ez.showAds(id); } catch (_) {}
           if (wrap) scheduleUncollapseChecks(wrap);
           scheduleEmptyCheck(id, t);
           setTimeout(() => { clearTimeout(timer); release(); }, TIMING.SHOW_RELEASE_MS);
         };
-
         Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
-      } catch (_) {
-        clearTimeout(timer);
-        release();
-      }
+      } catch (_) { clearTimeout(timer); release(); }
     });
   }
 
   function scheduleEmptyCheck(id, showTs) {
-    // Two-pass check: conservative to avoid collapsing slow-loading ads
-    for (const delay of [TIMING.EMPTY_CHECK_EARLY_MS, TIMING.EMPTY_CHECK_LATE_MS]) {
+    for (const delay of [TIMING.EMPTY_CHECK_MS_1, TIMING.EMPTY_CHECK_MS_2]) {
       setTimeout(() => {
         try {
           const ph   = document.getElementById(`${PH_PREFIX}${id}`);
@@ -686,9 +554,7 @@
           if (!wrap || !ph?.isConnected) return;
           if (parseInt(wrap.getAttribute(ATTR.SHOWN) || '0', 10) > showTs) return;
           if (clearEmptyIfFilled(wrap)) return;
-          // Don't collapse if a GPT slot exists (might still be loading)
           if (ph.querySelector('[id^="div-gpt-ad"]')) return;
-          // Don't collapse if placeholder has meaningful height
           if (ph.offsetHeight > 10) return;
           wrap.classList.add('is-empty');
         } catch (_) {}
@@ -697,10 +563,6 @@
   }
 
   // ── Patch Ezoic showAds ────────────────────────────────────────────────────
-  //
-  // Intercepts ez.showAds() to batch calls and filter disconnected placeholders.
-  // IMPORTANT: no-arg showAds() calls (used by Ezoic for page transitions)
-  // are passed through unmodified.
 
   function patchShowAds() {
     const apply = () => {
@@ -709,53 +571,22 @@
         const ez = window.ezstandalone;
         if (window.__nbbEzPatched || typeof ez.showAds !== 'function') return;
         window.__nbbEzPatched = true;
-
         const orig = ez.showAds.bind(ez);
-        const queue = new Set();
-        let flushTimer = null;
-
-        const flush = () => {
-          flushTimer = null;
-          if (isBlocked() || !queue.size) return;
-          const ids = Array.from(queue).sort((a, b) => a - b);
-          queue.clear();
-          const valid = ids.filter(id => {
-            const ph = document.getElementById(`${PH_PREFIX}${id}`);
-            if (!ph?.isConnected) { state.phState.delete(id); return false; }
-            if (isPlaceholderUsed(ph)) { state.phState.set(id, 'shown'); return false; }
-            return true;
-          });
-          for (let i = 0; i < valid.length; i += LIMITS.BATCH_SIZE) {
-            const chunk = valid.slice(i, i + LIMITS.BATCH_SIZE);
-            try { orig(...chunk); } catch (_) {
-              for (const cid of chunk) { try { orig(cid); } catch (_) {} }
-            }
-          }
-        };
-
         ez.showAds = function (...args) {
-          // No-arg call = Ezoic page refresh — pass through unmodified
-          if (args.length === 0) {
-            return orig();
-          }
+          if (!args.length) return orig();
           if (isBlocked()) return;
           const ids = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+          const seen = new Set();
           for (const v of ids) {
             const id = parseInt(v, 10);
-            if (!Number.isFinite(id) || id <= 0) continue;
-            const ph = document.getElementById(`${PH_PREFIX}${id}`);
-            if (!ph?.isConnected) continue;
-            if (isPlaceholderUsed(ph)) { state.phState.set(id, 'shown'); continue; }
-            state.phState.set(id, 'show-queued');
-            queue.add(id);
-          }
-          if (queue.size && !flushTimer) {
-            flushTimer = setTimeout(flush, TIMING.BATCH_FLUSH_MS);
+            if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
+            if (!document.getElementById(`${PH_PREFIX}${id}`)?.isConnected) continue;
+            seen.add(id);
+            try { orig(id); } catch (_) {}
           }
         };
       } catch (_) {}
     };
-
     apply();
     if (!window.__nbbEzPatched) {
       window.ezstandalone = window.ezstandalone || {};
@@ -767,6 +598,7 @@
 
   async function runCore() {
     if (isBlocked()) return 0;
+    patchShowAds();
     try { gcDisconnectedWraps(); } catch (_) {}
 
     const cfg = await fetchConfig();
@@ -778,37 +610,26 @@
 
     const exec = (klass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
       if (!normBool(cfgEnable)) return 0;
-      const interval = Math.max(1, parseInt(cfgInterval, 10) || 3);
-      return injectBetween(klass, getItems(), interval, normBool(cfgShowFirst), poolKey);
+      return injectBetween(klass, getItems(), Math.max(1, parseInt(cfgInterval, 10) || 3), normBool(cfgShowFirst), poolKey);
     };
 
-    if (kind === 'topic') {
-      return exec(
-        'ezoic-ad-message', getPosts,
-        cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts'
-      );
-    }
+    if (kind === 'topic')
+      return exec('ezoic-ad-message', getPosts, cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts');
     if (kind === 'categoryTopics') {
       pruneOrphansBetween();
-      return exec(
-        'ezoic-ad-between', getTopics,
-        cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics'
-      );
+      return exec('ezoic-ad-between', getTopics, cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics');
     }
-    return exec(
-      'ezoic-ad-categories', getCategories,
-      cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories'
-    );
+    return exec('ezoic-ad-categories', getCategories, cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories');
   }
 
-  // ── Scheduler & burst ──────────────────────────────────────────────────────
+  // ── Scheduler ──────────────────────────────────────────────────────────────
 
   function scheduleRun(cb) {
-    if (state.runQueued) return;
-    state.runQueued = true;
+    if (S.runQueued) return;
+    S.runQueued = true;
     requestAnimationFrame(async () => {
-      state.runQueued = false;
-      if (state.pageKey && pageKey() !== state.pageKey) return;
+      S.runQueued = false;
+      if (S.pageKey && pageKey() !== S.pageKey) return;
       let n = 0;
       try { n = await runCore(); } catch (_) {}
       try { cb?.(n); } catch (_) {}
@@ -818,70 +639,55 @@
   function requestBurst() {
     if (isBlocked()) return;
     const t = now();
-    if (t - state.lastBurstTs < TIMING.BURST_COOLDOWN_MS) return;
-    state.lastBurstTs   = t;
-    state.pageKey       = pageKey();
-    state.burstDeadline = t + LIMITS.BURST_WINDOW_MS;
-    if (state.burstActive) return;
-    state.burstActive = true;
-    state.burstCount  = 0;
+    if (t - S.lastBurstTs < TIMING.BURST_COOLDOWN_MS) return;
+    S.lastBurstTs   = t;
+    S.pageKey       = pageKey();
+    S.burstDeadline = t + BURST_WINDOW_MS;
+    if (S.burstActive) return;
+    S.burstActive = true;
+    S.burstCount  = 0;
     const step = () => {
-      if (pageKey() !== state.pageKey || isBlocked() || now() > state.burstDeadline || state.burstCount >= LIMITS.MAX_BURST_STEPS) {
-        state.burstActive = false;
-        return;
+      if (pageKey() !== S.pageKey || isBlocked() || now() > S.burstDeadline || S.burstCount >= MAX_BURST_STEPS) {
+        S.burstActive = false; return;
       }
-      state.burstCount++;
+      S.burstCount++;
       scheduleRun(n => {
-        if (!n && !state.pending.length) { state.burstActive = false; return; }
+        if (!n && !S.pending.length) { S.burstActive = false; return; }
         setTimeout(step, n > 0 ? 150 : 300);
       });
     };
     step();
   }
 
-  // ── Cleanup on navigation ──────────────────────────────────────────────────
+  // ── Cleanup ────────────────────────────────────────────────────────────────
 
   function cleanup() {
-    state.blockedUntil = now() + TIMING.BLOCK_DURATION_MS;
-
-    // Tell Ezoic to destroy all placeholders BEFORE we remove DOM elements.
-    // This prevents GPT slotDestroyed events and Ezoic 400 errors.
-    try {
-      const ez = window.ezstandalone;
-      if (typeof ez?.destroyAll === 'function') {
-        ez.destroyAll();
-      }
-    } catch (_) {}
-
+    S.blockedUntil = now() + TIMING.BLOCK_DURATION_MS;
     mutate(() => {
       for (const w of document.querySelectorAll(`.${WRAP_CLASS}`)) dropWrap(w);
     });
-    state.cfg          = null;
-    state.poolsReady   = false;
-    state.pools        = { topics: [], posts: [], categories: [] };
-    state.cursors      = { topics: 0, posts: 0, categories: 0 };
-    state.mountedIds.clear();
-    state.lastShow.clear();
-    state.wrapByKey.clear();
-    state.wrapsByClass.clear();
-    state.kind         = null;
-    state.phState.clear();
-    state.inflight     = 0;
-    state.pending      = [];
-    state.pendingSet.clear();
-    state.burstActive  = false;
-    state.runQueued    = false;
-    state.firstShown   = false;
+    S.cfg        = null;
+    S.poolsReady = false;
+    S.pools      = { topics: [], posts: [], categories: [] };
+    S.cursors    = { topics: 0, posts: 0, categories: 0 };
+    S.mountedIds.clear();
+    S.lastShow.clear();
+    S.wrapByKey.clear();
+    S.wrapsByClass.clear();
+    S.kind       = null;
+    S.inflight   = 0;
+    S.pending    = [];
+    S.pendingSet.clear();
+    S.burstActive = false;
+    S.runQueued   = false;
   }
 
   // ── MutationObserver ───────────────────────────────────────────────────────
 
   function ensureDomObserver() {
-    if (state.domObs) return;
-
-    state.domObs = new MutationObserver(muts => {
-      if (state.mutGuard > 0 || isBlocked()) return;
-
+    if (S.domObs) return;
+    S.domObs = new MutationObserver(muts => {
+      if (S.mutGuard > 0 || isBlocked()) return;
       let needsBurst = false;
       const kind = getKind();
       const relevantSels =
@@ -889,141 +695,77 @@
         kind === 'categoryTopics' ? [SEL.topic]    :
         kind === 'categories'     ? [SEL.category] :
                                     [SEL.post, SEL.topic, SEL.category];
-
+      outer:
       for (const m of muts) {
         if (m.type !== 'childList') continue;
-
-        // Free IDs from wraps removed by NodeBB virtualization
         for (const node of m.removedNodes) {
           if (!(node instanceof Element)) continue;
           try {
-            if (node.classList?.contains(WRAP_CLASS)) {
-              dropWrap(node);
-            } else {
-              const wraps = node.querySelectorAll?.(`.${WRAP_CLASS}`);
-              if (wraps?.length) { for (const w of wraps) dropWrap(w); }
-            }
+            if (node.classList?.contains(WRAP_CLASS)) dropWrap(node);
+            else { const ws = node.querySelectorAll?.(`.${WRAP_CLASS}`); if (ws?.length) for (const w of ws) dropWrap(w); }
           } catch (_) {}
         }
-
         for (const node of m.addedNodes) {
           if (!(node instanceof Element)) continue;
-
-          // Ad fill detection
           try {
             if (node.matches?.(FILL_SEL) || node.querySelector?.(FILL_SEL)) {
-              const wrap = node.closest?.(`.${WRAP_CLASS}.is-empty`) ||
-                           m.target?.closest?.(`.${WRAP_CLASS}.is-empty`);
+              const wrap = node.closest?.(`.${WRAP_CLASS}.is-empty`) || m.target?.closest?.(`.${WRAP_CLASS}.is-empty`);
               if (wrap) clearEmptyIfFilled(wrap);
             }
           } catch (_) {}
-
-          // Re-observe wraps re-inserted by NodeBB virtualization
           try {
-            const wraps = node.classList?.contains(WRAP_CLASS)
-              ? [node]
-              : Array.from(node.querySelectorAll?.(`.${WRAP_CLASS}`) || []);
-            for (const wrap of wraps) {
+            const reinserted = node.classList?.contains(WRAP_CLASS) ? [node] : Array.from(node.querySelectorAll?.(`.${WRAP_CLASS}`) || []);
+            for (const wrap of reinserted) {
               const id = parseInt(wrap.getAttribute(ATTR.WRAPID), 10);
-              if (!id || id <= 0) continue;
-              const ph = wrap.querySelector(`[id^="${PH_PREFIX}"]`);
-              if (ph) { try { getIO()?.observe(ph); } catch (_) {} }
+              if (id > 0) { const ph = wrap.querySelector(`[id^="${PH_PREFIX}"]`); if (ph) try { getIO()?.observe(ph); } catch (_) {} }
             }
           } catch (_) {}
-
-          // New content detection
           if (!needsBurst) {
             for (const sel of relevantSels) {
-              try {
-                if (node.matches(sel) || node.querySelector(sel)) { needsBurst = true; break; }
-              } catch (_) {}
+              try { if (node.matches(sel) || node.querySelector(sel)) { needsBurst = true; break outer; } } catch (_) {}
             }
           }
         }
-        if (needsBurst) break;
       }
-
       if (needsBurst) requestBurst();
     });
-
-    try {
-      state.domObs.observe(document.body, { childList: true, subtree: true });
-    } catch (_) {}
+    try { S.domObs.observe(document.body, { childList: true, subtree: true }); } catch (_) {}
   }
 
-  // ── TCF / CMP Protection (3 layers) ────────────────────────────────────────
+  // ── TCF / CMP Protection ───────────────────────────────────────────────────
 
   function ensureTcfLocator() {
     if (!window.__tcfapi && !window.__cmp) return;
-
     const LOCATOR_ID = '__tcfapiLocator';
-
     const ensureInHead = () => {
-      let existing = document.getElementById(LOCATOR_ID);
-      if (existing) {
-        if (existing.parentElement !== document.head) {
-          try { document.head.appendChild(existing); } catch (_) {}
-        }
-        return existing;
-      }
+      let el = document.getElementById(LOCATOR_ID);
+      if (el) { if (el.parentElement !== document.head) try { document.head.appendChild(el); } catch (_) {} return; }
       const f = document.createElement('iframe');
-      f.style.display = 'none';
-      f.id = f.name = LOCATOR_ID;
-      try { document.head.appendChild(f); } catch (_) {
-        (document.body || document.documentElement).appendChild(f);
-      }
-      return f;
+      f.style.display = 'none'; f.id = f.name = LOCATOR_ID;
+      try { document.head.appendChild(f); } catch (_) { (document.body || document.documentElement).appendChild(f); }
     };
-
     ensureInHead();
-
     if (!window.__nbbCmpGuarded) {
       window.__nbbCmpGuarded = true;
       if (typeof window.__tcfapi === 'function') {
-        const origTcf = window.__tcfapi;
-        window.__tcfapi = function (cmd, version, cb, param) {
-          try {
-            return origTcf.call(this, cmd, version, function (...args) {
-              try { cb?.(...args); } catch (_) {}
-            }, param);
-          } catch (e) {
-            if (e?.message?.includes('null')) {
-              ensureInHead();
-              try { return origTcf.call(this, cmd, version, cb, param); } catch (_) {}
-            }
-          }
+        const orig = window.__tcfapi;
+        window.__tcfapi = function (cmd, ver, cb, param) {
+          try { return orig.call(this, cmd, ver, function (...a) { try { cb?.(...a); } catch (_) {} }, param); }
+          catch (e) { if (e?.message?.includes('null')) { ensureInHead(); try { return orig.call(this, cmd, ver, cb, param); } catch (_) {} } }
         };
       }
       if (typeof window.__cmp === 'function') {
-        const origCmp = window.__cmp;
-        window.__cmp = function (...args) {
-          try { return origCmp.apply(this, args); }
-          catch (e) {
-            if (e?.message?.includes('null')) {
-              ensureInHead();
-              try { return origCmp.apply(this, args); } catch (_) {}
-            }
-          }
+        const orig = window.__cmp;
+        window.__cmp = function (...a) {
+          try { return orig.apply(this, a); }
+          catch (e) { if (e?.message?.includes('null')) { ensureInHead(); try { return orig.apply(this, a); } catch (_) {} } }
         };
       }
     }
-
     if (!window.__nbbTcfObs) {
-      window.__nbbTcfObs = new MutationObserver(() => {
-        if (!document.getElementById(LOCATOR_ID)) ensureInHead();
-      });
-      try {
-        window.__nbbTcfObs.observe(document.body || document.documentElement, {
-          childList: true, subtree: false,
-        });
-      } catch (_) {}
-      try {
-        if (document.head) {
-          window.__nbbTcfObs.observe(document.head, {
-            childList: true, subtree: false,
-          });
-        }
-      } catch (_) {}
+      window.__nbbTcfObs = new MutationObserver(() => { if (!document.getElementById(LOCATOR_ID)) ensureInHead(); });
+      try { window.__nbbTcfObs.observe(document.body || document.documentElement, { childList: true, subtree: false }); } catch (_) {}
+      try { if (document.head) window.__nbbTcfObs.observe(document.head, { childList: true, subtree: false }); } catch (_) {}
     }
   }
 
@@ -1031,21 +773,10 @@
 
   function protectAriaHidden() {
     if (window.__nbbAriaObs) return;
-    const remove = () => {
-      try {
-        if (document.body.getAttribute('aria-hidden') === 'true') {
-          document.body.removeAttribute('aria-hidden');
-        }
-      } catch (_) {}
-    };
-    remove();
-    window.__nbbAriaObs = new MutationObserver(remove);
-    try {
-      window.__nbbAriaObs.observe(document.body, {
-        attributes: true,
-        attributeFilter: ['aria-hidden'],
-      });
-    } catch (_) {}
+    const fix = () => { try { if (document.body.getAttribute('aria-hidden') === 'true') document.body.removeAttribute('aria-hidden'); } catch (_) {} };
+    fix();
+    window.__nbbAriaObs = new MutationObserver(fix);
+    try { window.__nbbAriaObs.observe(document.body, { attributes: true, attributeFilter: ['aria-hidden'] }); } catch (_) {}
   }
 
   // ── Console muting ─────────────────────────────────────────────────────────
@@ -1053,33 +784,27 @@
   function muteConsole() {
     if (window.__nbbEzMuted) return;
     window.__nbbEzMuted = true;
-
-    const PREFIXES = [
-      '[EzoicAds JS]: Placeholder Id',
-      'No valid placeholders for loadMore',
-      'cannot call refresh on the same page',
-      'no placeholders are currently defined in Refresh',
-      'Debugger iframe already exists',
-      '[CMP] Error in custom getTCData',
-      'vignette: no interstitial API',
-      'Ezoic JS-Enable should only ever',
-    ];
-    const PATTERNS = [
+    const MUTED = [
       `with id ${PH_PREFIX}`,
-      'adsbygoogle.push() error: All',
-      'has already been defined',
+      'adsbygoogle.push() error',
+      'already been defined',
       'bad response. Status',
+      'slotDestroyed',
+      'identity bridging',
+      '[EzoicAds JS]: Placeholder',
+      'No valid placeholders',
+      'cannot call refresh',
+      'no placeholders are currently defined',
+      'Debugger iframe already',
+      'Error in custom getTCData',
+      'no interstitial API',
+      'JS-Enable should only',
     ];
-
     for (const method of ['log', 'info', 'warn', 'error']) {
       const orig = console[method];
       if (typeof orig !== 'function') continue;
       console[method] = function (...args) {
-        if (typeof args[0] === 'string') {
-          const msg = args[0];
-          for (const p of PREFIXES) { if (msg.startsWith(p)) return; }
-          for (const p of PATTERNS) { if (msg.includes(p)) return; }
-        }
+        if (typeof args[0] === 'string') { for (const p of MUTED) if (args[0].includes(p)) return; }
         return orig.apply(console, args);
       };
     }
@@ -1087,28 +812,25 @@
 
   // ── Network warmup ─────────────────────────────────────────────────────────
 
-  let _networkWarmed = false;
-
+  let _warmed = false;
   function warmNetwork() {
-    if (_networkWarmed) return;
-    _networkWarmed = true;
+    if (_warmed) return;
+    _warmed = true;
     const head = document.head;
     if (!head) return;
-    const hints = [
+    for (const [rel, href, cors] of [
       ['preconnect',   'https://g.ezoic.net',                    true ],
       ['preconnect',   'https://go.ezoic.net',                   true ],
       ['preconnect',   'https://securepubads.g.doubleclick.net', true ],
       ['preconnect',   'https://pagead2.googlesyndication.com',  true ],
       ['dns-prefetch', 'https://g.ezoic.net',                    false],
       ['dns-prefetch', 'https://securepubads.g.doubleclick.net', false],
-    ];
-    for (const [rel, href, cors] of hints) {
+    ]) {
       if (head.querySelector(`link[rel="${rel}"][href="${href}"]`)) continue;
-      const link = document.createElement('link');
-      link.rel = rel;
-      link.href = href;
-      if (cors) link.crossOrigin = 'anonymous';
-      head.appendChild(link);
+      const l = document.createElement('link');
+      l.rel = rel; l.href = href;
+      if (cors) l.crossOrigin = 'anonymous';
+      head.appendChild(l);
     }
   }
 
@@ -1117,57 +839,25 @@
   function bindNodeBB() {
     const $ = window.jQuery;
     if (!$) return;
-
     $(window).off('.nbbEzoic');
-
-    // Only cleanup on actual page change, not same-page pagination
-    $(window).on('action:ajaxify.start.nbbEzoic', (ev, data) => {
-      const targetUrl = data?.url || data?.tpl_url || '';
-      const currentPath = location.pathname.replace(/^\//, '');
-      if (targetUrl && targetUrl.replace(/[?#].*$/, '') === currentPath.replace(/[?#].*$/, '')) {
-        return; // Same page — skip cleanup
-      }
-      cleanup();
-    });
-
+    $(window).on('action:ajaxify.start.nbbEzoic', cleanup);
     $(window).on('action:ajaxify.end.nbbEzoic', () => {
-      state.pageKey    = pageKey();
-      state.kind       = null;
-      state.blockedUntil = 0;
-
-      muteConsole();
-      ensureTcfLocator();
-      protectAriaHidden();
-      warmNetwork();
-      patchShowAds();
-      getIO();
-      ensureDomObserver();
+      S.pageKey = pageKey(); S.kind = null; S.blockedUntil = 0;
+      muteConsole(); ensureTcfLocator(); protectAriaHidden();
+      warmNetwork(); patchShowAds(); getIO(); ensureDomObserver();
       requestBurst();
     });
-
-    const burstEvents = [
-      'action:ajaxify.contentLoaded',
-      'action:posts.loaded',
-      'action:topics.loaded',
-      'action:categories.loaded',
-      'action:category.loaded',
-      'action:topic.loaded',
+    const burstEvts = [
+      'action:ajaxify.contentLoaded', 'action:posts.loaded',
+      'action:topics.loaded', 'action:categories.loaded',
+      'action:category.loaded', 'action:topic.loaded',
     ].map(e => `${e}.nbbEzoic`).join(' ');
-
-    $(window).on(burstEvents, () => { if (!isBlocked()) requestBurst(); });
-
+    $(window).on(burstEvts, () => { if (!isBlocked()) requestBurst(); });
     try {
       require(['hooks'], hooks => {
         if (typeof hooks?.on !== 'function') return;
-        for (const ev of [
-          'action:ajaxify.end',
-          'action:posts.loaded',
-          'action:topics.loaded',
-          'action:categories.loaded',
-          'action:topic.loaded',
-        ]) {
+        for (const ev of ['action:ajaxify.end', 'action:posts.loaded', 'action:topics.loaded', 'action:categories.loaded', 'action:topic.loaded'])
           try { hooks.on(ev, () => { if (!isBlocked()) requestBurst(); }); } catch (_) {}
-        }
       });
     } catch (_) {}
   }
@@ -1175,18 +865,14 @@
   function bindScroll() {
     let ticking = false;
     window.addEventListener('scroll', () => {
-      if (ticking) return;
-      ticking = true;
-      requestAnimationFrame(() => {
-        ticking = false;
-        requestBurst();
-      });
+      if (ticking) return; ticking = true;
+      requestAnimationFrame(() => { ticking = false; requestBurst(); });
     }, { passive: true });
   }
 
   // ── Boot ───────────────────────────────────────────────────────────────────
 
-  state.pageKey = pageKey();
+  S.pageKey = pageKey();
   muteConsole();
   ensureTcfLocator();
   protectAriaHidden();
@@ -1196,7 +882,23 @@
   ensureDomObserver();
   bindNodeBB();
   bindScroll();
-  state.blockedUntil = 0;
+  S.blockedUntil = 0;
   requestBurst();
 
+  // Retry boot: sa.min.js async + Cloudflare Rocket Loader + NodeBB SPA
+  // can cause client.js to boot before DOM/Ezoic are ready.
+  // Retries stop once ads are mounted or after ~10s.
+  let _retries = 0;
+  function retryBoot() {
+    if (_retries >= 12 || S.mountedIds.size > 0) return;
+    _retries++;
+    patchShowAds();
+    if (!isBlocked() && !S.burstActive) {
+      S.lastBurstTs = 0;
+      requestBurst();
+    }
+    setTimeout(retryBoot, _retries <= 4 ? 300 : 1000);
+  }
+  setTimeout(retryBoot, 250);
+
 })();