nodebb-plugin-ezoic-infinite 1.8.47 → 1.8.49

package/library.js

@@ -141,12 +141,12 @@ const HEAD_PRECONNECTS = [
 const EZOIC_SCRIPTS = [
   '<script data-cfasync="false" src="https://cmp.gatekeeperconsent.com/min.js"></script>',
   '<script data-cfasync="false" src="https://the.gatekeeperconsent.com/cmp.min.js"></script>',
+  '<script async src="//www.ezojs.com/ezoic/sa.min.js"></script>',
   '<script>',
-  'window._ezaq = window._ezaq || {};',
   'window.ezstandalone = window.ezstandalone || {};',
-  'ezstandalone.cmd = ezstandalone.cmd || [];',
+  // Always reference through window to avoid ReferenceError in stricter contexts
+  'window.ezstandalone.cmd = window.ezstandalone.cmd || [];',
   '</script>',
-  '<script async src="//www.ezojs.com/ezoic/sa.min.js"></script>',
 ].join('\n');
 
 // ── Hooks ────────────────────────────────────────────────────────────────────
@@ -174,24 +174,7 @@ plugin.injectEzoicHead = async (data) => {
     const settings = await getSettings();
     const uid      = data.req?.uid ?? 0;
     const excluded = await isUserExcluded(uid, settings.excludedGroups);
-
-    if (excluded) {
-      // Even for excluded users, inject a minimal stub so that any script
-      // referencing ezstandalone doesn't throw a ReferenceError, plus
-      // the config with excluded=true so client.js bails early.
-      const cfg = buildClientConfig(settings, true);
-      const stub = [
-        '<script>',
-        'window._ezaq = window._ezaq || {};',
-        'window.ezstandalone = window.ezstandalone || {};',
-        'ezstandalone.cmd = ezstandalone.cmd || [];',
-        '</script>',
-      ].join('\n');
-      data.templateData.customHTML =
-        stub + '\n' +
-        serializeInlineConfig(cfg) +
-        (data.templateData.customHTML || '');
-    } else {
+    if (!excluded) {
       const cfg = buildClientConfig(settings, false);
       data.templateData.customHTML =
         HEAD_PRECONNECTS + '\n' +
@@ -200,6 +183,7 @@ plugin.injectEzoicHead = async (data) => {
         (data.templateData.customHTML || '');
     }
   } catch (err) {
+    // Log but don't break rendering
     console.error('[ezoic-infinite] injectEzoicHead error:', err.message);
   }
   return data;

package/package.json

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

package/public/client.js

@@ -1,12 +1,15 @@
 /**
- * NodeBB Ezoic Infinite Ads — client.js v2.2.0
+ * NodeBB Ezoic Infinite Ads — client.js v2.0.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
+ * Complete rewrite: performance optimization, CMP/TCF fix, clean architecture.
+ *
+ * Key changes from v1.x:
+ * - TCF locator: debounced recreation instead of per-mutation, prevents CMP postMessage null errors
+ * - MutationObserver: scoped to content containers instead of document.body subtree
+ * - Console muting: regex-free, prefix-based matching
+ * - showAds batching: microtask-based flush instead of setTimeout
+ * - Warm network: runs once per session, not per navigation
+ * - State machine: clear lifecycle for placeholders (idle → observed → queued → shown → recycled)
  */
 (function nbbEzoicInfinite() {
   'use strict';
@@ -16,6 +19,7 @@
   const WRAP_CLASS = 'nodebb-ezoic-wrap';
   const PH_PREFIX  = 'ezoic-pub-ad-placeholder-';
 
+  // Data attributes
   const ATTR = {
     ANCHOR:  'data-ezoic-anchor',
     WRAPID:  'data-ezoic-wrapid',
@@ -23,19 +27,21 @@
     SHOWN:   'data-ezoic-shown',
   };
 
+  // Timing
   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:    20_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,
+
   };
 
+  // Limits
   const LIMITS = {
     MAX_INSERTS_RUN: 6,
     MAX_INFLIGHT:    4,
@@ -49,20 +55,22 @@
     MOBILE:  '3500px 0px 3500px 0px',
   };
 
+  // Selectors
   const SEL = {
     post:     '[component="post"][data-pid]',
     topic:    'li[component="category/topic"]',
     category: 'li[component="categories/category"]',
   };
 
+  // Kind configuration table — single source of truth per ad type
   const KIND = {
     'ezoic-ad-message':    { sel: SEL.post,     baseTag: '',   anchorAttr: 'data-pid',   ordinalAttr: 'data-index' },
     'ezoic-ad-between':    { sel: SEL.topic,    baseTag: 'li', anchorAttr: 'data-index', ordinalAttr: 'data-index' },
     'ezoic-ad-categories': { sel: SEL.category, baseTag: 'li', anchorAttr: 'data-cid',   ordinalAttr: null         },
   };
 
+  // Selector for detecting filled ad slots
   const FILL_SEL = 'iframe, ins, img, video, [data-google-container-id], div[id$="__container__"]';
-  const RECYCLE_MIN_AGE_MS = 5_000;
 
   // ── Utility ────────────────────────────────────────────────────────────────
 
@@ -95,37 +103,45 @@
   // ── State ──────────────────────────────────────────────────────────────────
 
   const state = {
+    // Page context
     pageKey:    null,
     kind:       null,
     cfg:        null,
 
+    // Pools
     poolsReady: false,
     pools:      { topics: [], posts: [], categories: [] },
     cursors:    { topics: 0,  posts: 0,  categories: 0  },
 
+    // Mounted placeholders
     mountedIds: new Set(),
     phState:    new Map(),  // id → 'new' | 'show-queued' | 'shown' | 'destroyed'
     lastShow:   new Map(),  // id → timestamp
 
-    wrapByKey:    new Map(),
-    wrapsByClass: new Map(),
+    // Wrap registry
+    wrapByKey:    new Map(),  // anchorKey → wrap element
+    wrapsByClass: new Map(),  // kindClass → Set<wrap>
 
+    // Observers
     io:     null,
     domObs: null,
 
-    mutGuard:     0,
+    // Guards
+    mutGuard:   0,
     blockedUntil: 0,
 
+    // Show queue
     inflight:   0,
     pending:    [],
     pendingSet: new Set(),
 
-    runQueued:     false,
-    burstActive:   false,
+    // Scheduler
+    runQueued:    false,
+    burstActive:  false,
     burstDeadline: 0,
-    burstCount:    0,
-    lastBurstTs:   0,
-    firstShown:    false,
+    burstCount:   0,
+    lastBurstTs:  0,
+    firstShown:   false,
   };
 
   const isBlocked = () => now() < state.blockedUntil;
@@ -139,6 +155,7 @@
 
   async function fetchConfig() {
     if (state.cfg) return state.cfg;
+    // Prefer inline config injected by server (zero latency)
     try {
       const inline = window.__nbbEzoicCfg;
       if (inline && typeof inline === 'object') {
@@ -146,6 +163,7 @@
         return state.cfg;
       }
     } catch (_) {}
+    // Fallback to API
     try {
       const r = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
       if (r.ok) state.cfg = await r.json();
@@ -177,6 +195,7 @@
     if (/^\/topic\//.test(p))                 return 'topic';
     if (/^\/category\//.test(p))              return 'categoryTopics';
     if (p === '/' || /^\/categories/.test(p)) return 'categories';
+    // DOM fallback
     if (document.querySelector(SEL.category)) return 'categories';
     if (document.querySelector(SEL.post))     return 'topic';
     if (document.querySelector(SEL.topic))    return 'categoryTopics';
@@ -196,6 +215,7 @@
       const el = all[i];
       if (!el.isConnected) continue;
       if (!el.querySelector('[component="post/content"]')) continue;
+      // Skip nested quotes / parent posts
       const parent = el.parentElement?.closest(SEL.post);
       if (parent && parent !== el) continue;
       if (el.getAttribute('component') === 'post/parent') continue;
@@ -215,6 +235,7 @@
       const v = el.getAttribute(attr);
       if (v != null && v !== '') return v;
     }
+    // Positional fallback
     const children = el.parentElement?.children;
     if (!children) return 'i0';
     for (let i = 0; i < children.length; i++) {
@@ -236,12 +257,20 @@
     return set;
   }
 
-  // ── GC disconnected wraps (NodeBB virtualization) ──────────────────────────
+  // ── Garbage collection (NodeBB post virtualization safe) ─────────────────
+  //
+  // NodeBB can remove large portions of the DOM during infinite scrolling
+  // (especially posts in topics). If a wrap is removed outside of our own
+  // dropWrap(), we must free its placeholder id; otherwise the pool appears
+  // exhausted and ads won't re-insert when the user scrolls back up.
 
   function gcDisconnectedWraps() {
+    // 1) Clean wrapByKey
     for (const [key, w] of Array.from(state.wrapByKey.entries())) {
       if (!w?.isConnected) state.wrapByKey.delete(key);
     }
+
+    // 2) Clean wrapsByClass sets and free ids
     for (const [klass, set] of Array.from(state.wrapsByClass.entries())) {
       for (const w of Array.from(set)) {
         if (w?.isConnected) continue;
@@ -257,12 +286,15 @@
       }
       if (!set.size) state.wrapsByClass.delete(klass);
     }
+
+    // 3) Authoritative rebuild of mountedIds from the live DOM
     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);
       }
+      // Drop any ids that are no longer live
       for (const id of Array.from(state.mountedIds)) {
         if (!live.has(id)) {
           state.mountedIds.delete(id);
@@ -275,16 +307,26 @@
 
   // ── Wrap lifecycle detection ───────────────────────────────────────────────
 
+  /**
+   * Check if a wrap element still has its corresponding anchor in the DOM.
+   * Uses O(1) registry lookup first, then sibling scan, then global querySelector.
+   */
   function wrapIsLive(wrap) {
     if (!wrap?.classList?.contains(WRAP_CLASS)) return false;
     const key = wrap.getAttribute(ATTR.ANCHOR);
     if (!key) return false;
+
+    // Fast path: registry match
     if (state.wrapByKey.get(key) === wrap) return wrap.isConnected;
+
+    // Parse key
     const colonIdx = key.indexOf(':');
     const klass    = key.slice(0, colonIdx);
     const anchorId = key.slice(colonIdx + 1);
     const cfg = KIND[klass];
     if (!cfg) return false;
+
+    // Sibling scan (cheap for adjacent anchors)
     const parent = wrap.parentElement;
     if (parent) {
       const sel = `${cfg.baseTag || ''}[${cfg.anchorAttr}="${anchorId}"]`;
@@ -294,6 +336,8 @@
         }
       }
     }
+
+    // Global fallback (expensive, rare)
     try {
       return document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`)?.isConnected === true;
     } catch (_) { return false; }
@@ -317,8 +361,11 @@
 
   function scheduleUncollapseChecks(wrap) {
     if (!wrap) return;
-    for (const ms of [500, 1500, 3000, 7000, 15000]) {
-      setTimeout(() => { try { clearEmptyIfFilled(wrap); } catch (_) {} }, ms);
+    const delays = [500, 1500, 3000, 7000, 15000];
+    for (const ms of delays) {
+      setTimeout(() => {
+        try { clearEmptyIfFilled(wrap); } catch (_) {}
+      }, ms);
     }
   }
 
@@ -337,18 +384,19 @@
   }
 
   // ── Recycling ──────────────────────────────────────────────────────────────
-  //
-  // Per Ezoic docs: destroyPlaceholders(id) → remove old HTML →
-  // recreate fresh placeholder → showAds(id).
 
+  /**
+   * When pool is exhausted, recycle a wrap far above the viewport.
+   * Sequence: destroy → delay → re-observe → enqueueShow
+   */
   function recycleWrap(klass, targetEl, newKey) {
     const ez = window.ezstandalone;
     if (typeof ez?.destroyPlaceholders !== 'function' ||
-        typeof ez?.showAds             !== 'function') return null;
+        typeof ez?.define             !== 'function' ||
+        typeof ez?.displayMore        !== 'function') return null;
 
     const vh = window.innerHeight || 800;
-    const threshold = -(3 * vh);
-    const t = now();
+    const threshold = -vh;
     let bestEmpty = null, bestEmptyY = Infinity;
     let bestFull  = null, bestFullY  = Infinity;
 
@@ -357,13 +405,6 @@
 
     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;
-
         const bottom = wrap.getBoundingClientRect().bottom;
         if (bottom > threshold) continue;
         if (!isFilled(wrap)) {
@@ -382,48 +423,47 @@
 
     const oldKey = best.getAttribute(ATTR.ANCHOR);
 
-    // Unobserve before moving
+    // Unobserve before moving to prevent stale showAds
     try {
       const ph = best.querySelector(`#${PH_PREFIX}${id}`);
       if (ph) state.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);
-        });
+    // Move the wrap to 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);
+    // Update registry
+    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);
+    // Ezoic recycle sequence
+    const doDestroy = () => {
+      state.phState.set(id, 'destroyed');
+      try { ez.destroyPlaceholders(id); } catch (_) {
+        try { ez.destroyPlaceholders([id]); } catch (_) {}
+      }
+      setTimeout(() => {
+        try { observePlaceholder(id); } catch (_) {}
+        state.phState.set(id, 'new');
+        try { enqueueShow(id); } catch (_) {}
       }, TIMING.RECYCLE_DELAY_MS);
     };
 
     try {
-      (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doRecycle) : doRecycle();
+      (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doDestroy) : doDestroy();
     } catch (_) {}
 
     return { id, wrap: best };
@@ -452,6 +492,7 @@
     if (!el?.insertAdjacentElement) return null;
     if (findWrap(key)) return null;
     if (state.mountedIds.has(id)) return null;
+    // Ensure no duplicate DOM element with same placeholder ID
     const existing = document.getElementById(`${PH_PREFIX}${id}`);
     if (existing?.isConnected) return null;
 
@@ -468,13 +509,17 @@
     try {
       const ph = w.querySelector(`[id^="${PH_PREFIX}"]`);
       if (ph instanceof Element) state.io?.unobserve(ph);
+
       const id = parseInt(w.getAttribute(ATTR.WRAPID), 10);
       if (Number.isFinite(id)) {
         state.mountedIds.delete(id);
         state.phState.delete(id);
       }
+
       const key = w.getAttribute(ATTR.ANCHOR);
       if (key && state.wrapByKey.get(key) === w) state.wrapByKey.delete(key);
+
+      // Find the kind class to unregister
       for (const cls of w.classList) {
         if (cls !== WRAP_CLASS && cls.startsWith('ezoic-ad-')) {
           state.wrapsByClass.get(cls)?.delete(w);
@@ -486,6 +531,9 @@
   }
 
   // ── Prune (category topic lists only) ──────────────────────────────────────
+  //
+  // Safe for category topic lists: NodeBB does NOT virtualize topics in categories.
+  // NOT safe for posts: NodeBB virtualizes posts off-viewport.
 
   function pruneOrphansBetween() {
     const klass = 'ezoic-ad-between';
@@ -493,6 +541,7 @@
     const wraps = state.wrapsByClass.get(klass);
     if (!wraps?.size) return;
 
+    // Build set of live anchor IDs
     const liveAnchors = new Set();
     for (const el of document.querySelectorAll(`${cfg.baseTag}[${cfg.anchorAttr}]`)) {
       const v = el.getAttribute(cfg.anchorAttr);
@@ -503,6 +552,7 @@
     for (const w of 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)) {
@@ -519,6 +569,7 @@
       const v = el.getAttribute(attr);
       if (v != null && v !== '' && !isNaN(v)) return parseInt(v, 10);
     }
+    // Positional fallback
     const fullSel = KIND[klass]?.sel ?? '';
     let i = 0;
     for (const s of el.parentElement?.children ?? []) {
@@ -553,7 +604,7 @@
         }
       } else {
         const recycled = recycleWrap(klass, el, key);
-        if (!recycled) break;
+        if (!recycled) break;  // Pool truly exhausted
         inserted++;
       }
     }
@@ -677,30 +728,25 @@
   }
 
   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]) {
-      setTimeout(() => {
-        try {
-          const ph   = document.getElementById(`${PH_PREFIX}${id}`);
-          const wrap = ph?.closest(`.${WRAP_CLASS}`);
-          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 (_) {}
-      }, delay);
-    }
+    setTimeout(() => {
+      try {
+        const ph   = document.getElementById(`${PH_PREFIX}${id}`);
+        const wrap = ph?.closest(`.${WRAP_CLASS}`);
+        if (!wrap || !ph?.isConnected) return;
+        // Skip if a newer show happened since
+        if (parseInt(wrap.getAttribute(ATTR.SHOWN) || '0', 10) > showTs) return;
+        if (clearEmptyIfFilled(wrap)) return;
+        wrap.classList.add('is-empty');
+      } catch (_) {}
+    }, TIMING.EMPTY_CHECK_MS);
   }
 
   // ── 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.
+  // Intercepts ez.showAds() to:
+  //   - block calls during navigation transitions
+  //   - filter out disconnected placeholders
+  //   - batch calls for efficiency
 
   function patchShowAds() {
     const apply = () => {
@@ -717,14 +763,17 @@
         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 (_) {
@@ -734,10 +783,6 @@
         };
 
         ez.showAds = function (...args) {
-          // No-arg call = Ezoic page refresh — pass through unmodified
-          if (args.length === 0) {
-            return orig();
-          }
           if (isBlocked()) return;
           const ids = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
           for (const v of ids) {
@@ -767,6 +812,9 @@
 
   async function runCore() {
     if (isBlocked()) return 0;
+
+    // Keep internal pools in sync with NodeBB DOM virtualization/removals
+    // so ads can re-insert correctly when users scroll back up.
     try { gcDisconnectedWraps(); } catch (_) {}
 
     const cfg = await fetchConfig();
@@ -788,6 +836,7 @@
         cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts'
       );
     }
+
     if (kind === 'categoryTopics') {
       pruneOrphansBetween();
       return exec(
@@ -795,6 +844,7 @@
         cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics'
       );
     }
+
     return exec(
       'ezoic-ad-categories', getCategories,
       cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories'
@@ -822,9 +872,11 @@
     state.lastBurstTs   = t;
     state.pageKey       = pageKey();
     state.burstDeadline = t + LIMITS.BURST_WINDOW_MS;
+
     if (state.burstActive) return;
     state.burstActive = true;
     state.burstCount  = 0;
+
     const step = () => {
       if (pageKey() !== state.pageKey || isBlocked() || now() > state.burstDeadline || state.burstCount >= LIMITS.MAX_BURST_STEPS) {
         state.burstActive = false;
@@ -843,18 +895,10 @@
 
   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 (_) {}
-
     mutate(() => {
-      for (const w of document.querySelectorAll(`.${WRAP_CLASS}`)) dropWrap(w);
+      for (const w of document.querySelectorAll(`.${WRAP_CLASS}`)) {
+        dropWrap(w);
+      }
     });
     state.cfg          = null;
     state.poolsReady   = false;
@@ -875,6 +919,8 @@
   }
 
   // ── MutationObserver ───────────────────────────────────────────────────────
+  //
+  // Scoped to detect: (1) ad fill events in wraps, (2) new content items
 
   function ensureDomObserver() {
     if (state.domObs) return;
@@ -883,17 +929,19 @@
       if (state.mutGuard > 0 || isBlocked()) return;
 
       let needsBurst = false;
+
+      // Determine relevant selectors for current page kind
       const kind = getKind();
       const relevantSels =
-        kind === 'topic'          ? [SEL.post]     :
-        kind === 'categoryTopics' ? [SEL.topic]    :
-        kind === 'categories'     ? [SEL.category] :
-                                    [SEL.post, SEL.topic, SEL.category];
+        kind === 'topic'         ? [SEL.post]     :
+        kind === 'categoryTopics'? [SEL.topic]    :
+        kind === 'categories'    ? [SEL.category] :
+                                   [SEL.post, SEL.topic, SEL.category];
 
       for (const m of muts) {
         if (m.type !== 'childList') continue;
 
-        // Free IDs from wraps removed by NodeBB virtualization
+        // If NodeBB removed wraps as part of virtualization, free ids immediately
         for (const node of m.removedNodes) {
           if (!(node instanceof Element)) continue;
           try {
@@ -901,7 +949,9 @@
               dropWrap(node);
             } else {
               const wraps = node.querySelectorAll?.(`.${WRAP_CLASS}`);
-              if (wraps?.length) { for (const w of wraps) dropWrap(w); }
+              if (wraps?.length) {
+                for (const w of wraps) dropWrap(w);
+              }
             }
           } catch (_) {}
         }
@@ -909,7 +959,7 @@
         for (const node of m.addedNodes) {
           if (!(node instanceof Element)) continue;
 
-          // Ad fill detection
+          // Check for ad fill events in wraps
           try {
             if (node.matches?.(FILL_SEL) || node.querySelector?.(FILL_SEL)) {
               const wrap = node.closest?.(`.${WRAP_CLASS}.is-empty`) ||
@@ -918,24 +968,14 @@
             }
           } 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 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 (_) {} }
-            }
-          } catch (_) {}
-
-          // New content detection
+          // Check for new content items (posts, topics, categories)
           if (!needsBurst) {
             for (const sel of relevantSels) {
               try {
-                if (node.matches(sel) || node.querySelector(sel)) { needsBurst = true; break; }
+                if (node.matches(sel) || node.querySelector(sel)) {
+                  needsBurst = true;
+                  break;
+                }
               } catch (_) {}
             }
           }
@@ -951,25 +991,52 @@
     } catch (_) {}
   }
 
-  // ── TCF / CMP Protection (3 layers) ────────────────────────────────────────
+  // ── TCF / CMP Protection ─────────────────────────────────────────────────
+  //
+  // Root cause of the CMP errors:
+  //   "Cannot read properties of null (reading 'postMessage')"
+  //   "Cannot set properties of null (setting 'addtlConsent')"
+  //
+  // The CMP (Gatekeeper Consent) communicates via postMessage on the
+  // __tcfapiLocator iframe's contentWindow. During NodeBB ajaxify navigation,
+  // jQuery's html() or empty() on the content area can cascade and remove
+  // iframes from <body>. The CMP then calls getTCData on a stale reference
+  // where contentWindow is null.
+  //
+  // Strategy (3 layers):
+  //
+  //  1. PROTECT: Move the locator iframe into <head> where ajaxify never
+  //     touches it. The TCF spec only requires the iframe to exist in the
+  //     document with name="__tcfapiLocator" — it works from <head>.
+  //
+  //  2. GUARD: Wrap __tcfapi and __cmp with a safety layer that catches
+  //     errors in the CMP's internal getTCData, preventing the uncaught
+  //     TypeError from propagating.
+  //
+  //  3. RESTORE: MutationObserver on <body> childList (not subtree) to
+  //     immediately re-create the locator if something still removes it.
 
   function ensureTcfLocator() {
     if (!window.__tcfapi && !window.__cmp) return;
 
     const LOCATOR_ID = '__tcfapiLocator';
 
+    // Create or relocate the locator iframe into <head> for protection
     const ensureInHead = () => {
       let existing = document.getElementById(LOCATOR_ID);
       if (existing) {
+        // If it's in <body>, move it to <head> where ajaxify can't reach it
         if (existing.parentElement !== document.head) {
           try { document.head.appendChild(existing); } catch (_) {}
         }
         return existing;
       }
+      // Create fresh
       const f = document.createElement('iframe');
       f.style.display = 'none';
       f.id = f.name = LOCATOR_ID;
       try { document.head.appendChild(f); } catch (_) {
+        // Fallback to body if head insertion fails
         (document.body || document.documentElement).appendChild(f);
       }
       return f;
@@ -977,8 +1044,11 @@
 
     ensureInHead();
 
+    // Layer 2: Guard the CMP API calls against null contentWindow
     if (!window.__nbbCmpGuarded) {
       window.__nbbCmpGuarded = true;
+
+      // Wrap __tcfapi
       if (typeof window.__tcfapi === 'function') {
         const origTcf = window.__tcfapi;
         window.__tcfapi = function (cmd, version, cb, param) {
@@ -987,18 +1057,23 @@
               try { cb?.(...args); } catch (_) {}
             }, param);
           } catch (e) {
+            // If the error is the null postMessage/addtlConsent, swallow it
             if (e?.message?.includes('null')) {
+              // Re-ensure locator exists, then retry once
               ensureInHead();
               try { return origTcf.call(this, cmd, version, cb, param); } catch (_) {}
             }
           }
         };
       }
+
+      // Wrap __cmp (legacy CMP v1 API)
       if (typeof window.__cmp === 'function') {
         const origCmp = window.__cmp;
         window.__cmp = function (...args) {
-          try { return origCmp.apply(this, args); }
-          catch (e) {
+          try {
+            return origCmp.apply(this, args);
+          } catch (e) {
             if (e?.message?.includes('null')) {
               ensureInHead();
               try { return origCmp.apply(this, args); } catch (_) {}
@@ -1008,47 +1083,37 @@
       }
     }
 
+    // Layer 3: MutationObserver to immediately restore if removed
     if (!window.__nbbTcfObs) {
-      window.__nbbTcfObs = new MutationObserver(() => {
-        if (!document.getElementById(LOCATOR_ID)) ensureInHead();
+      window.__nbbTcfObs = new MutationObserver(muts => {
+        // Fast check: still in document?
+        if (document.getElementById(LOCATOR_ID)) return;
+        // Something removed it — restore immediately (no debounce)
+        ensureInHead();
       });
+      // Observe body direct children only (the most likely removal point)
       try {
         window.__nbbTcfObs.observe(document.body || document.documentElement, {
-          childList: true, subtree: false,
+          childList: true,
+          subtree: false,
         });
       } catch (_) {}
+      // Also observe <head> in case something cleans it
       try {
         if (document.head) {
           window.__nbbTcfObs.observe(document.head, {
-            childList: true, subtree: false,
+            childList: true,
+            subtree: false,
           });
         }
       } catch (_) {}
     }
   }
 
-  // ── aria-hidden protection ─────────────────────────────────────────────────
-
-  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 (_) {}
-  }
-
   // ── Console muting ─────────────────────────────────────────────────────────
+  //
+  // Mute noisy Ezoic warnings that are expected in infinite scroll context.
+  // Uses startsWith checks instead of includes for performance.
 
   function muteConsole() {
     if (window.__nbbEzMuted) return;
@@ -1062,14 +1127,8 @@
       'Debugger iframe already exists',
       '[CMP] Error in custom getTCData',
       'vignette: no interstitial API',
-      'Ezoic JS-Enable should only ever',
-    ];
-    const PATTERNS = [
-      `with id ${PH_PREFIX}`,
-      'adsbygoogle.push() error: All',
-      'has already been defined',
-      'bad response. Status',
     ];
+    const PH_PATTERN = `with id ${PH_PREFIX}`;
 
     for (const method of ['log', 'info', 'warn', 'error']) {
       const orig = console[method];
@@ -1077,8 +1136,10 @@
       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; }
+          for (const prefix of PREFIXES) {
+            if (msg.startsWith(prefix)) return;
+          }
+          if (msg.includes(PH_PATTERN)) return;
         }
         return orig.apply(console, args);
       };
@@ -1086,14 +1147,17 @@
   }
 
   // ── Network warmup ─────────────────────────────────────────────────────────
+  // Run once per session — preconnect hints are in <head> via server-side injection
 
   let _networkWarmed = false;
 
   function warmNetwork() {
     if (_networkWarmed) return;
     _networkWarmed = true;
+
     const head = document.head;
     if (!head) return;
+
     const hints = [
       ['preconnect',   'https://g.ezoic.net',                    true ],
       ['preconnect',   'https://go.ezoic.net',                   true ],
@@ -1102,6 +1166,7 @@
       ['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');
@@ -1120,24 +1185,18 @@
 
     $(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;
 
+      // Fix: CMP modal can leave aria-hidden="true" on <body> after navigation
+      try { document.body.removeAttribute('aria-hidden'); } catch (_) {}
+
       muteConsole();
       ensureTcfLocator();
-      protectAriaHidden();
       warmNetwork();
       patchShowAds();
       getIO();
@@ -1145,6 +1204,7 @@
       requestBurst();
     });
 
+    // Content-loaded events trigger burst
     const burstEvents = [
       'action:ajaxify.contentLoaded',
       'action:posts.loaded',
@@ -1156,6 +1216,7 @@
 
     $(window).on(burstEvents, () => { if (!isBlocked()) requestBurst(); });
 
+    // Also bind via NodeBB hooks module (for compatibility)
     try {
       require(['hooks'], hooks => {
         if (typeof hooks?.on !== 'function') return;
@@ -1189,7 +1250,6 @@
   state.pageKey = pageKey();
   muteConsole();
   ensureTcfLocator();
-  protectAriaHidden();
   warmNetwork();
   patchShowAds();
   getIO();