nodebb-plugin-ezoic-infinite 1.8.42 → 1.8.43

package/library.js

@@ -141,11 +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 || [];',
   '</script>',
+  '<script async src="//www.ezojs.com/ezoic/sa.min.js"></script>',
 ].join('\n');
 
 // ── Hooks ────────────────────────────────────────────────────────────────────
@@ -173,7 +174,24 @@ plugin.injectEzoicHead = async (data) => {
     const settings = await getSettings();
     const uid      = data.req?.uid ?? 0;
     const excluded = await isUserExcluded(uid, settings.excludedGroups);
-    if (!excluded) {
+
+    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 {
       const cfg = buildClientConfig(settings, false);
       data.templateData.customHTML =
         HEAD_PRECONNECTS + '\n' +
@@ -182,7 +200,6 @@ 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.42",
+  "version": "1.8.43",
   "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",

package/public/client.js

@@ -1,15 +1,16 @@
 /**
- * NodeBB Ezoic Infinite Ads — client.js v2.0.0
+ * NodeBB Ezoic Infinite Ads — client.js v3.0.0
  *
- * Complete rewrite: performance optimization, CMP/TCF fix, clean architecture.
+ * Ezoic API usage per official docs:
+ * https://docs.ezoic.com/docs/ezoicads/dynamic-content/
  *
- * 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)
+ *   NEW PLACEHOLDERS:  ez.cmd.push(() => ez.showAds(id1, id2, ...))
+ *   RECYCLE (reuse ID): ez.cmd.push(() => ez.destroyPlaceholders(id))
+ *                       → remove old HTML → create fresh placeholder
+ *                       → ez.cmd.push(() => ez.showAds(id))
+ *
+ * phState per placeholder ID:
+ *   new → displayed → [destroyed → new]  (recycle loop)
  */
 (function nbbEzoicInfinite() {
   'use strict';
@@ -19,7 +20,6 @@
   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',
@@ -27,25 +27,19 @@
     SHOWN:   'data-ezoic-shown',
   };
 
-  // Timing
   const TIMING = {
     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,
-    TCF_DEBOUNCE_MS:      500,
+    BATCH_FLUSH_MS:       120,
+    RECYCLE_DESTROY_MS:   300,
+    RECYCLE_SHOW_MS:      300,
   };
 
-  // Limits
   const LIMITS = {
     MAX_INSERTS_RUN: 6,
-    MAX_INFLIGHT:    4,
-    BATCH_SIZE:      3,
     MAX_BURST_STEPS: 8,
     BURST_WINDOW_MS: 2_000,
   };
@@ -55,47 +49,39 @@
     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 ────────────────────────────────────────────────────────────────
 
   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 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;
   }
 
   function parseIds(raw) {
-    const out = [];
-    const seen = new Set();
+    const out = [], 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);
-      }
+      if (n > 0 && Number.isFinite(n) && !seen.has(n)) { seen.add(n); out.push(n); }
     }
     return out;
   }
@@ -103,45 +89,29 @@
   // ── State ──────────────────────────────────────────────────────────────────
 
   const state = {
-    // Page context
-    pageKey:    null,
-    kind:       null,
-    cfg:        null,
+    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
-
-    // Wrap registry
-    wrapByKey:    new Map(),  // anchorKey → wrap element
-    wrapsByClass: new Map(),  // kindClass → Set<wrap>
+    pools:   { topics: [], posts: [], categories: [] },
+    cursors: { topics: 0,  posts: 0,  categories: 0  },
 
-    // Observers
-    io:     null,
-    domObs: null,
+    mountedIds:   new Set(),
+    // phState: 'new' | 'displayed' | 'destroyed'
+    phState:      new Map(),
+    lastShow:     new Map(),
+    wrapByKey:    new Map(),
+    wrapsByClass: new Map(),
 
-    // Guards
-    mutGuard:   0,
-    blockedUntil: 0,
+    io: null, domObs: null,
+    mutGuard: 0, blockedUntil: 0,
 
-    // Show queue
-    inflight:   0,
-    pending:    [],
-    pendingSet: new Set(),
+    // Ezoic batch queue: ids waiting for define+displayMore
+    ezBatch:      new Set(),
+    ezFlushTimer: null,
 
-    // Scheduler
+    // Lifecycle
     runQueued:    false,
-    burstActive:  false,
-    burstDeadline: 0,
-    burstCount:   0,
-    lastBurstTs:  0,
-    firstShown:   false,
+    burstActive:  false, burstDeadline: 0, burstCount: 0, lastBurstTs: 0,
   };
 
   const isBlocked = () => now() < state.blockedUntil;
@@ -155,15 +125,10 @@
 
   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') {
-        state.cfg = inline;
-        return state.cfg;
-      }
+      if (inline && typeof inline === 'object') { state.cfg = inline; 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();
@@ -195,27 +160,22 @@
     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';
     return 'other';
   }
 
-  function getKind() {
-    return state.kind || (state.kind = detectKind());
-  }
+  function getKind() { return state.kind || (state.kind = detectKind()); }
 
   // ── DOM queries ────────────────────────────────────────────────────────────
 
   function getPosts() {
-    const all = document.querySelectorAll(SEL.post);
-    const out = [];
+    const all = document.querySelectorAll(SEL.post), out = [];
     for (let i = 0; i < all.length; i++) {
       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;
@@ -223,7 +183,6 @@
     }
     return out;
   }
-
   function getTopics()     { return Array.from(document.querySelectorAll(SEL.topic)); }
   function getCategories() { return Array.from(document.querySelectorAll(SEL.category)); }
 
@@ -231,16 +190,10 @@
 
   function stableId(klass, el) {
     const attr = KIND[klass]?.anchorAttr;
-    if (attr) {
-      const v = el.getAttribute(attr);
-      if (v != null && v !== '') return v;
-    }
-    // Positional fallback
+    if (attr) { const v = el.getAttribute(attr); if (v != null && v !== '') return v; }
     const children = el.parentElement?.children;
     if (!children) return 'i0';
-    for (let i = 0; i < children.length; i++) {
-      if (children[i] === el) return `i${i}`;
-    }
+    for (let i = 0; i < children.length; i++) { if (children[i] === el) return `i${i}`; }
     return 'i0';
   }
 
@@ -252,47 +205,30 @@
   }
 
   function getWrapSet(klass) {
-    let set = state.wrapsByClass.get(klass);
-    if (!set) { set = new Set(); state.wrapsByClass.set(klass, set); }
-    return set;
+    let s = state.wrapsByClass.get(klass);
+    if (!s) { s = new Set(); state.wrapsByClass.set(klass, s); }
+    return s;
   }
 
-  // ── Wrap lifecycle detection ───────────────────────────────────────────────
+  // ── Wrap lifecycle ─────────────────────────────────────────────────────────
 
-  /**
-   * 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 klass = key.slice(0, colonIdx), 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}"]`;
       for (const sib of parent.children) {
-        if (sib !== wrap) {
-          try { if (sib.matches(sel)) return sib.isConnected; } catch (_) {}
-        }
+        if (sib !== wrap) { try { if (sib.matches(sel)) return sib.isConnected; } catch (_) {} }
       }
     }
-
-    // Global fallback (expensive, rare)
-    try {
-      return document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`)?.isConnected === true;
-    } catch (_) { return false; }
+    try { return document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`)?.isConnected === true; } catch (_) { return false; }
   }
 
   function adjacentWrap(el) {
@@ -307,21 +243,18 @@
     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');
+    if (id > 0) state.phState.set(id, 'displayed');
     return true;
   }
 
   function scheduleUncollapseChecks(wrap) {
     if (!wrap) return;
-    const delays = [500, 1500, 3000, 7000, 15000];
-    for (const ms of delays) {
-      setTimeout(() => {
-        try { clearEmptyIfFilled(wrap); } catch (_) {}
-      }, ms);
+    for (const ms of [500, 1500, 3000, 7000, 15000]) {
+      setTimeout(() => { try { clearEmptyIfFilled(wrap); } catch (_) {} }, ms);
     }
   }
 
-  // ── Pool management ────────────────────────────────────────────────────────
+  // ── Pool ───────────────────────────────────────────────────────────────────
 
   function pickId(poolKey) {
     const pool = state.pools[poolKey];
@@ -335,20 +268,110 @@
     return null;
   }
 
-  // ── Recycling ──────────────────────────────────────────────────────────────
+  // ── Ezoic API layer ────────────────────────────────────────────────────────
+  //
+  // Correct Ezoic infinite scroll flow:
+  //   First batch:  ez.cmd.push(() => { ez.define(...ids); ez.enable(); })
+  //   Next batches: ez.cmd.push(() => { ez.define(...ids); ez.displayMore(...ids); })
+  //   Recycle:      ez.cmd.push(() => { ez.destroyPlaceholders(id); })
+  //                 → wait → new DOM → ez.cmd.push(() => { ez.define(id); ez.displayMore(id); })
+  //
+  // We batch define+displayMore calls using ezBatch to avoid calling the
+  // Ezoic API on every single placeholder insertion.
+
+  function ezCmd(fn) {
+    window.ezstandalone = window.ezstandalone || {};
+    const ez = window.ezstandalone;
+    if (Array.isArray(ez.cmd)) {
+      ez.cmd.push(fn);
+    } else {
+      try { fn(); } catch (_) {}
+    }
+  }
 
   /**
-   * When pool is exhausted, recycle a wrap far above the viewport.
-   * Sequence: destroy → delay → re-observe → enqueueShow
+   * Queue a placeholder ID for the next batched showAds call.
    */
+  function ezEnqueue(id) {
+    if (isBlocked()) return;
+    state.ezBatch.add(id);
+    if (!state.ezFlushTimer) {
+      state.ezFlushTimer = setTimeout(ezFlush, TIMING.BATCH_FLUSH_MS);
+    }
+  }
+
+  /**
+   * Flush: call showAds() for all queued IDs.
+   *
+   * Per Ezoic docs (https://docs.ezoic.com/docs/ezoicads/dynamic-content/):
+   *   - New placeholders: ez.showAds(id1, id2, ...)
+   *   - After destroy+recreate: ez.showAds(id) again
+   *   - No define(), no enable(), no displayMore()
+   */
+  function ezFlush() {
+    state.ezFlushTimer = null;
+    if (isBlocked() || !state.ezBatch.size) return;
+
+    // Filter to only valid, connected, unfilled placeholders
+    const ids = [];
+    for (const id of state.ezBatch) {
+      const ph = document.getElementById(`${PH_PREFIX}${id}`);
+      if (!ph?.isConnected) { state.phState.delete(id); continue; }
+      if (isPlaceholderUsed(ph)) { state.phState.set(id, 'displayed'); continue; }
+      ids.push(id);
+    }
+    state.ezBatch.clear();
+    if (!ids.length) return;
+
+    ezCmd(() => {
+      const ez = window.ezstandalone;
+      if (typeof ez?.showAds !== 'function') return;
+
+      try { ez.showAds(...ids); } catch (_) {}
+
+      // Mark as displayed and schedule fill checks
+      for (const id of ids) {
+        state.phState.set(id, 'displayed');
+        state.lastShow.set(id, now());
+        const ph = document.getElementById(`${PH_PREFIX}${id}`);
+        const wrap = ph?.closest(`.${WRAP_CLASS}`);
+        if (wrap) {
+          wrap.setAttribute(ATTR.SHOWN, String(now()));
+          scheduleUncollapseChecks(wrap);
+        }
+        scheduleEmptyCheck(id);
+      }
+    });
+  }
+
+  function scheduleEmptyCheck(id) {
+    const showTs = now();
+    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;
+        wrap.classList.add('is-empty');
+      } catch (_) {}
+    }, TIMING.EMPTY_CHECK_MS);
+  }
+
+  // ── Recycling ──────────────────────────────────────────────────────────────
+  //
+  // Per Ezoic docs: when reusing placeholder IDs in infinite scroll,
+  // call destroyPlaceholders(id) first, remove the old HTML, recreate
+  // a fresh placeholder div, then call showAds(id) again.
+
   function recycleWrap(klass, targetEl, newKey) {
     const ez = window.ezstandalone;
     if (typeof ez?.destroyPlaceholders !== 'function' ||
-        typeof ez?.define             !== 'function' ||
-        typeof ez?.displayMore        !== 'function') return null;
+        typeof ez?.showAds             !== 'function') return null;
 
     const vh = window.innerHeight || 800;
-    const threshold = -vh;
+    const threshold = -(3 * vh);
+    const t = now();
     let bestEmpty = null, bestEmptyY = Infinity;
     let bestFull  = null, bestFullY  = Infinity;
 
@@ -357,6 +380,11 @@
 
     for (const wrap of wraps) {
       try {
+        const created = parseInt(wrap.getAttribute(ATTR.CREATED) || '0', 10);
+        if (t - created < RECYCLE_MIN_AGE_MS) continue;
+        const wid = parseInt(wrap.getAttribute(ATTR.WRAPID), 10);
+        const st = state.phState.get(wid);
+        if (st === 'new') continue;  // not yet shown, don't recycle
         const bottom = wrap.getBoundingClientRect().bottom;
         if (bottom > threshold) continue;
         if (!isFilled(wrap)) {
@@ -375,48 +403,48 @@
 
     const oldKey = best.getAttribute(ATTR.ANCHOR);
 
-    // Unobserve before moving to prevent stale showAds
+    // Unobserve before moving
     try {
       const ph = best.querySelector(`#${PH_PREFIX}${id}`);
       if (ph) state.io?.unobserve(ph);
     } catch (_) {}
 
-    // 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);
-    });
+    state.phState.set(id, 'destroyed');
 
-    // Update registry
-    if (oldKey && state.wrapByKey.get(oldKey) === best) state.wrapByKey.delete(oldKey);
-    state.wrapByKey.set(newKey, best);
+    // Step 1: destroyPlaceholders(id)
+    // Step 2: remove old HTML, create fresh placeholder at new position
+    // Step 3: showAds(id)
+    ezCmd(() => {
+      try { ez.destroyPlaceholders(id); } catch (_) {}
 
-    // 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(doDestroy) : doDestroy();
-    } catch (_) {}
+        // Recreate placeholder DOM
+        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);
+
+        // showAds again after DOM is ready
+        setTimeout(() => {
+          state.phState.set(id, 'new');
+          observePlaceholder(id);
+          ezEnqueue(id);
+        }, TIMING.RECYCLE_SHOW_MS);
+      }, TIMING.RECYCLE_DESTROY_MS);
+    });
 
     return { id, wrap: best };
   }
@@ -431,7 +459,6 @@
     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));
@@ -444,10 +471,8 @@
     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;
-
     const w = makeWrap(id, klass, key);
     mutate(() => el.insertAdjacentElement('afterend', w));
     state.mountedIds.add(id);
@@ -461,21 +486,13 @@
     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);
-      }
-
+      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);
-          break;
+          state.wrapsByClass.get(cls)?.delete(w); break;
         }
       }
       w.remove();
@@ -483,33 +500,24 @@
   }
 
   // ── 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';
     const cfg   = KIND[klass];
     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);
       if (v) liveAnchors.add(v);
     }
-
     const t = now();
     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)) {
-        mutate(() => dropWrap(w));
-      }
+      if (!sid || !liveAnchors.has(sid)) mutate(() => dropWrap(w));
     }
   }
 
@@ -521,7 +529,6 @@
       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 ?? []) {
@@ -538,11 +545,9 @@
     for (const el of items) {
       if (inserted >= LIMITS.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;
 
@@ -551,12 +556,13 @@
         const w = insertAfter(el, id, klass, key);
         if (w) {
           observePlaceholder(id);
-          if (!state.firstShown) { state.firstShown = true; enqueueShow(id); }
+          // Queue for batched define+enable/displayMore
+          ezEnqueue(id);
           inserted++;
         }
       } else {
         const recycled = recycleWrap(klass, el, key);
-        if (!recycled) break;  // Pool truly exhausted
+        if (!recycled) break;
         inserted++;
       }
     }
@@ -564,6 +570,12 @@
   }
 
   // ── IntersectionObserver ───────────────────────────────────────────────────
+  //
+  // The IO is used to eagerly observe placeholders so that when they enter
+  // the viewport margin, we can queue them for Ezoic. However, the actual
+  // Ezoic API calls (define/displayMore) happen in the batched flush.
+  // The IO callback is mainly useful for re-triggering after NodeBB
+  // virtualisation re-inserts posts.
 
   function getIO() {
     if (state.io) return state.io;
@@ -571,9 +583,19 @@
       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);
-          if (id > 0) enqueueShow(id);
+          const target = entry.target;
+          if (target instanceof Element) state.io?.unobserve(target);
+          const id = parseInt(target.getAttribute('data-ezoic-id'), 10);
+          if (!id || id <= 0) continue;
+          const st = state.phState.get(id);
+          // Only enqueue if not yet processed by Ezoic
+          if (st === 'new') {
+            ezEnqueue(id);
+          } else if (st === 'displayed') {
+            // Already shown — check if the placeholder is actually filled.
+            // If not (Ezoic had no ad), don't re-trigger — it won't help.
+            // If yes, nothing to do.
+          }
         }
       }, {
         root: null,
@@ -586,189 +608,16 @@
 
   function observePlaceholder(id) {
     const ph = document.getElementById(`${PH_PREFIX}${id}`);
-    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');
-      }
-      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);
-      startShow(id);
-    }
-  }
-
-  function startShow(id) {
-    if (!id || isBlocked()) return;
-    state.inflight++;
-
-    let released = false;
-    const release = () => {
-      if (released) return;
-      released = true;
-      state.inflight = Math.max(0, state.inflight - 1);
-      drainQueue();
-    };
-    const timer = setTimeout(release, TIMING.SHOW_TIMEOUT_MS);
-
-    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();
-        }
-
-        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');
-
-        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();
-      }
-    });
-  }
-
-  function scheduleEmptyCheck(id, showTs) {
-    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:
-  //   - block calls during navigation transitions
-  //   - filter out disconnected placeholders
-  //   - batch calls for efficiency
-
-  function patchShowAds() {
-    const apply = () => {
-      try {
-        window.ezstandalone = window.ezstandalone || {};
-        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) {
-          if (isBlocked()) return;
-          const ids = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
-          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);
-          }
-        };
-      } catch (_) {}
-    };
-
-    apply();
-    if (!window.__nbbEzPatched) {
-      window.ezstandalone = window.ezstandalone || {};
-      (window.ezstandalone.cmd = window.ezstandalone.cmd || []).push(apply);
-    }
+    if (ph?.isConnected) { try { getIO()?.observe(ph); } catch (_) {} }
   }
 
   // ── Core ───────────────────────────────────────────────────────────────────
 
   async function runCore() {
     if (isBlocked()) return 0;
-
     const cfg = await fetchConfig();
     if (!cfg || cfg.excluded) return 0;
     initPools(cfg);
-
     const kind = getKind();
     if (kind === 'other') return 0;
 
@@ -779,24 +628,16 @@
     };
 
     if (kind === 'topic') {
-      return exec(
-        'ezoic-ad-message', getPosts,
-        cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts'
-      );
+      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 ──────────────────────────────────────────────────────
@@ -820,78 +661,68 @@
     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;
-        return;
+        state.burstActive = false; return;
       }
       state.burstCount++;
       scheduleRun(n => {
-        if (!n && !state.pending.length) { state.burstActive = false; return; }
+        if (!n && !state.ezBatch.size) { state.burstActive = false; return; }
         setTimeout(step, n > 0 ? 150 : 300);
       });
     };
     step();
   }
 
-  // ── Cleanup on navigation ──────────────────────────────────────────────────
+  // ── Cleanup ────────────────────────────────────────────────────────────────
 
   function cleanup() {
     state.blockedUntil = now() + TIMING.BLOCK_DURATION_MS;
+
+    // Cancel pending Ezoic batch
+    if (state.ezFlushTimer) { clearTimeout(state.ezFlushTimer); state.ezFlushTimer = null; }
+    state.ezBatch.clear();
+
     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;
-    state.pools        = { topics: [], posts: [], categories: [] };
-    state.cursors      = { topics: 0, posts: 0, categories: 0 };
+    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.kind = null;
     state.phState.clear();
-    state.inflight     = 0;
-    state.pending      = [];
-    state.pendingSet.clear();
     state.burstActive  = false;
     state.runQueued    = false;
-    state.firstShown   = false;
   }
 
   // ── MutationObserver ───────────────────────────────────────────────────────
-  //
-  // Scoped to detect: (1) ad fill events in wraps, (2) new content items
 
   function ensureDomObserver() {
     if (state.domObs) return;
-
     state.domObs = new MutationObserver(muts => {
       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;
         for (const node of m.addedNodes) {
           if (!(node instanceof Element)) continue;
 
-          // Check for ad fill events in wraps
+          // Ad fill detection
           try {
             if (node.matches?.(FILL_SEL) || node.querySelector?.(FILL_SEL)) {
               const wrap = node.closest?.(`.${WRAP_CLASS}.is-empty`) ||
@@ -900,104 +731,121 @@
             }
           } catch (_) {}
 
-          // Check for new content items (posts, topics, categories)
+          // 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
           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 (_) {}
             }
           }
         }
         if (needsBurst) break;
       }
-
       if (needsBurst) requestBurst();
     });
-
-    try {
-      state.domObs.observe(document.body, { childList: true, subtree: true });
-    } catch (_) {}
+    try { state.domObs.observe(document.body, { childList: true, subtree: true }); } catch (_) {}
   }
 
-  // ── TCF Locator ────────────────────────────────────────────────────────────
-  //
-  // FIX: The CMP iframe locator (__tcfapiLocator) must exist for the CMP to
-  // communicate via postMessage. NodeBB's ajaxify can remove it during navigation.
-  //
-  // Previous approach: MutationObserver that re-injects on EVERY mutation → race
-  // conditions with CMP, causing "Cannot read properties of null (reading 'postMessage')"
-  // and "Cannot set properties of null (setting 'addtlConsent')".
-  //
-  // New approach: Debounced check — only re-inject after DOM stabilizes (500ms).
-  // The CMP scripts handle their own initialization; we just ensure the locator
-  // iframe exists when needed.
-
-  let _tcfDebounce = null;
+  // ── TCF / CMP Protection ───────────────────────────────────────────────────
 
   function ensureTcfLocator() {
-    // Only needed if CMP APIs are present
     if (!window.__tcfapi && !window.__cmp) return;
-
-    const inject = () => {
-      if (document.getElementById('__tcfapiLocator')) 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;
+      }
       const f = document.createElement('iframe');
-      f.style.display = 'none';
-      f.id = f.name = '__tcfapiLocator';
-      (document.body || document.documentElement).appendChild(f);
+      f.style.display = 'none'; f.id = f.name = LOCATOR_ID;
+      try { document.head.appendChild(f); } catch (_) {
+        (document.body || document.documentElement).appendChild(f);
+      }
     };
-
-    inject();
-
-    // Set up a debounced observer instead of per-mutation injection
+    ensureInHead();
+    if (!window.__nbbCmpGuarded) {
+      window.__nbbCmpGuarded = true;
+      if (typeof window.__tcfapi === 'function') {
+        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 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(() => {
-        // Quick check: if locator still exists, skip
-        if (document.getElementById('__tcfapiLocator')) return;
-        // Debounce: wait for DOM to stabilize before re-injecting
-        clearTimeout(_tcfDebounce);
-        _tcfDebounce = setTimeout(inject, TIMING.TCF_DEBOUNCE_MS);
-      });
-      // Observe only direct children of body (not deep subtree)
-      // since the locator iframe is a direct child
-      window.__nbbTcfObs.observe(document.body || document.documentElement, {
-        childList: true,
-        subtree: false,
+        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 (_) {}
     }
   }
 
+  // ── 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;
     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',
+    ];
+    const PATTERNS = [
+      `with id ${PH_PREFIX}`,
+      'adsbygoogle.push() error: All',
+      'has already been defined',
+      'No valid placeholders for loadMore',
+      'bad response. Status',
     ];
-    const PH_PATTERN = `with id ${PH_PREFIX}`;
-
     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 prefix of PREFIXES) {
-            if (msg.startsWith(prefix)) return;
-          }
-          if (msg.includes(PH_PATTERN)) return;
+          for (const p of PREFIXES) { if (msg.startsWith(p)) return; }
+          for (const p of PATTERNS) { if (msg.includes(p)) return; }
         }
         return orig.apply(console, args);
       };
@@ -1005,31 +853,24 @@
   }
 
   // ── 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 = [
+    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;
+      link.rel = rel; link.href = href;
       if (cors) link.crossOrigin = 'anonymous';
       head.appendChild(link);
     }
@@ -1040,48 +881,25 @@
   function bindNodeBB() {
     const $ = window.jQuery;
     if (!$) return;
-
     $(window).off('.nbbEzoic');
-
     $(window).on('action:ajaxify.start.nbbEzoic', cleanup);
-
     $(window).on('action:ajaxify.end.nbbEzoic', () => {
-      state.pageKey    = pageKey();
-      state.kind       = null;
+      state.pageKey = pageKey();
+      state.kind = null;
       state.blockedUntil = 0;
-
-      muteConsole();
-      ensureTcfLocator();
-      warmNetwork();
-      patchShowAds();
-      getIO();
-      ensureDomObserver();
-      requestBurst();
+      muteConsole(); ensureTcfLocator(); protectAriaHidden(); warmNetwork();
+      getIO(); ensureDomObserver(); requestBurst();
     });
-
-    // Content-loaded events trigger burst
     const burstEvents = [
-      'action:ajaxify.contentLoaded',
-      'action:posts.loaded',
-      'action:topics.loaded',
-      'action:categories.loaded',
-      'action:category.loaded',
-      'action:topic.loaded',
+      '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(); });
-
-    // Also bind via NodeBB hooks module (for compatibility)
     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 (_) {}
         }
       });
@@ -1093,10 +911,7 @@
     window.addEventListener('scroll', () => {
       if (ticking) return;
       ticking = true;
-      requestAnimationFrame(() => {
-        ticking = false;
-        requestBurst();
-      });
+      requestAnimationFrame(() => { ticking = false; requestBurst(); });
     }, { passive: true });
   }
 
@@ -1105,8 +920,8 @@
   state.pageKey = pageKey();
   muteConsole();
   ensureTcfLocator();
+  protectAriaHidden();
   warmNetwork();
-  patchShowAds();
   getIO();
   ensureDomObserver();
   bindNodeBB();