nodebb-plugin-ezoic-infinite 1.6.67 → 1.6.69

package/public/client.js

@@ -1,756 +1,512 @@
 (function () {
   'use strict';
 
-  // ─── Scroll direction tracker ───────────────────────────────────────────────
-  // Prevents aggressive recycling when the user scrolls upward.
-  let lastScrollY = 0;
-  let scrollDir = 1; // 1 = down, -1 = up
-  try {
-    lastScrollY = window.scrollY || 0;
-    window.addEventListener('scroll', () => {
-      const y = window.scrollY || 0;
-      const d = y - lastScrollY;
-      if (Math.abs(d) > 4) { scrollDir = d > 0 ? 1 : -1; lastScrollY = y; }
-    }, { passive: true });
-  } catch (e) {}
+  // ─── Constants ───────────────────────────────────────────────────────────────
+  const WRAP_CLASS          = 'nodebb-ezoic-wrap';
+  const PLACEHOLDER_PREFIX  = 'ezoic-pub-ad-placeholder-';
+  const HOST_CLASS          = 'nodebb-ezoic-host';
+  const MAX_INSERTS_PER_RUN = 8;
 
-  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
+  // IntersectionObserver preload margins (large = request fills early).
+  const IO_MARGIN_DESKTOP = '2600px 0px 2600px 0px';
+  const IO_MARGIN_MOBILE  = '3200px 0px 3200px 0px';
 
-  // ─── Constants ──────────────────────────────────────────────────────────────
-  const WRAP_CLASS         = 'nodebb-ezoic-wrap';
-  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
-  const HOST_CLASS         = 'nodebb-ezoic-host';
-  const MAX_INSERTS_PER_RUN = 8;
+  // Fast-scroll boost: temporarily widen IO margins.
+  const IO_MARGIN_DESKTOP_BOOST = '5200px 0px 5200px 0px';
+  const IO_MARGIN_MOBILE_BOOST  = '5200px 0px 5200px 0px';
+  const BOOST_DURATION_MS       = 2500;
+  const BOOST_SPEED_PX_PER_MS   = 2.2;
 
-  function keepEmptyWrapMs() { return isMobile() ? 120_000 : 60_000; }
-
-  const PRELOAD_MARGIN_DESKTOP        = '2600px 0px 2600px 0px';
-  const PRELOAD_MARGIN_MOBILE         = '3200px 0px 3200px 0px';
-  const PRELOAD_MARGIN_DESKTOP_BOOST  = '5200px 0px 5200px 0px';
-  const PRELOAD_MARGIN_MOBILE_BOOST   = '5200px 0px 5200px 0px';
-  const BOOST_DURATION_MS             = 2500;
-  const BOOST_SPEED_PX_PER_MS         = 2.2;
-  const MAX_INFLIGHT_DESKTOP          = 4;
-  const MAX_INFLIGHT_MOBILE           = 3;
-
-  const SELECTORS = {
-    topicItem:    'li[component="category/topic"]',
-    postItem:     '[component="post"][data-pid]',
-    categoryItem: 'li[component="categories/category"]',
+  const MAX_INFLIGHT = { desktop: 4, mobile: 3 };
+
+  const SEL = {
+    topic:    'li[component="category/topic"]',
+    post:     '[component="post"][data-pid]',
+    category: 'li[component="categories/category"]',
   };
 
-  // ─── Shared helpers ─────────────────────────────────────────────────────────
+  // ─── Utils ───────────────────────────────────────────────────────────────────
+
+  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
 
   function now()      { return Date.now(); }
   function isMobile() { try { return window.innerWidth < 768; } catch (e) { return false; } }
-  function isBoosted(){ return now() < (state.scrollBoostUntil || 0); }
+  function isBoosted(){ return now() < (st.boostUntil || 0); }
+  function isBlocked(){ return now() < blockedUntil; }
 
-  function normalizeBool(v) {
+  function normBool(v) {
     return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
-  /** Returns true if the node contains a rendered ad creative. */
+  function parsePool(raw) {
+    if (!raw) return [];
+    const seen = new Set(), out = [];
+    for (const v of String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean)) {
+      const n = parseInt(v, 10);
+      if (Number.isFinite(n) && n > 0 && !seen.has(n)) { seen.add(n); out.push(n); }
+    }
+    return out;
+  }
+
   function isFilled(node) {
     return !!(node && node.querySelector &&
       node.querySelector('iframe, ins, img, video, [data-google-container-id]'));
   }
 
-  // ─── Console noise filter ───────────────────────────────────────────────────
-  function muteNoisyConsole() {
+  function getMaxInflight() {
+    return (isMobile() ? MAX_INFLIGHT.mobile : MAX_INFLIGHT.desktop) + (isBoosted() ? 1 : 0);
+  }
+
+  function getIoMargin() {
+    return isMobile()
+      ? (isBoosted() ? IO_MARGIN_MOBILE_BOOST  : IO_MARGIN_MOBILE)
+      : (isBoosted() ? IO_MARGIN_DESKTOP_BOOST : IO_MARGIN_DESKTOP);
+  }
+
+  function getPageKey() {
     try {
-      if (window.__nodebbEzoicConsoleMuted) return;
-      window.__nodebbEzoicConsoleMuted = true;
-      const shouldMute = (args) => {
-        try {
-          const s = typeof args[0] === 'string' ? args[0] : '';
-          return (
-            (s.includes('[EzoicAds JS]: Placeholder Id') && s.includes('has already been defined')) ||
-            s.includes('Debugger iframe already exists') ||
-            (s.includes('HTML element with id ezoic-pub-ad-placeholder-') && s.includes('does not exist'))
-          );
-        } catch (e) { return false; }
-      };
-      const wrap = (m) => {
-        const orig = console[m];
-        if (typeof orig !== 'function') return;
-        console[m] = function (...a) { if (shouldMute(a)) return; return orig.apply(console, a); };
+      const d = window.ajaxify && window.ajaxify.data;
+      if (d) {
+        if (d.tid) return 'topic:'    + d.tid;
+        if (d.cid) return 'category:' + d.cid;
+      }
+    } catch (e) {}
+    return window.location.pathname;
+  }
+
+  function getKind() {
+    const p = window.location.pathname || '';
+    if (/^\/topic\//.test(p))                          return 'topic';
+    if (/^\/category\//.test(p))                       return 'categoryTopics';
+    if (p === '/' || /^\/categories/.test(p))          return 'categories';
+    if (document.querySelector(SEL.category))          return 'categories';
+    if (document.querySelector(SEL.post))              return 'topic';
+    if (document.querySelector(SEL.topic))             return 'categoryTopics';
+    return 'other';
+  }
+
+  function withInternal(fn) {
+    st.internalMut++;
+    try { fn(); } finally { st.internalMut--; }
+  }
+
+  // ─── State ───────────────────────────────────────────────────────────────────
+
+  const st = {
+    pageKey: null,
+    cfg: null,
+
+    pools:   { topic: [], post: [], category: [] },
+    cursors: { topic: 0,  post: 0,  category: 0  },
+
+    lastShow:   new Map(),   // id → timestamp
+    inflight:   0,
+    pending:    [],
+    pendingSet: new Set(),
+
+    io:         null,
+    ioMargin:   null,
+    domObs:     null,
+
+    internalMut:  0,
+    boostUntil:   0,
+    lastScrollY:  0,
+    lastScrollTs: 0,
+
+    heroDone:     false,
+    runQueued:    false,
+    burstActive:  false,
+    burstDeadline:0,
+    burstCount:   0,
+    lastBurstTs:  0,
+
+    // Detached wraps cache (to survive NodeBB virtual/infinite scroll recycling)
+    // kindClass -> Map(afterPos -> wrapNode)
+    detached: new Map(),
+  };
+
+  let blockedUntil = 0;
+  const inserting  = new Set();
+
+  // ─── Console mute (Ezoic SPA spam) ───────────────────────────────────────────
+
+  function muteConsole() {
+    try {
+      if (window.__nbbEzoicMuted) return;
+      window.__nbbEzoicMuted = true;
+      const bad = (a) => {
+        const s = typeof a[0] === 'string' ? a[0] : '';
+        return (s.includes('[EzoicAds JS]: Placeholder Id') && s.includes('has already been defined'))
+            || s.includes('Debugger iframe already exists')
+            || (s.includes('HTML element with id ezoic-pub-ad-placeholder-') && s.includes('does not exist'));
       };
-      ['log','info','warn','error'].forEach(wrap);
+      for (const m of ['log','info','warn','error']) {
+        const o = console[m];
+        if (typeof o !== 'function') continue;
+        console[m] = function(...a) { if (!bad(a)) o.apply(console, a); };
+      }
     } catch (e) {}
   }
 
-  // ensureTcfApiLocator intentionally removed:
-  // Creating our own __tcfapiLocator iframe conflicts with the CMP's own locator
-  // management and causes "Cannot read properties of null (reading 'postMessage')"
-  // errors when the CMP tries to postMessage to an iframe we created then navigated away.
-  // The CMP (Ezoic/IAB TCF) handles its own locator iframe lifecycle.
-  function ensureTcfApiLocator() { /* no-op */ }
-
-  // ─── Ezoic min-height tightener ─────────────────────────────────────────────
-  // Ezoic injects `min-height:400px !important` on nested wrappers via inline
-  // style. CSS alone can't fix it — we must rewrite the inline style.
-  function tightenEzoicMinHeight(wrap) {
+  // ─── Network warmup ──────────────────────────────────────────────────────────
+
+  const _warmed = new Set();
+  function warmNetwork() {
+    const head = document.head;
+    if (!head) return;
+    for (const [rel, href, cors] of [
+      ['preconnect',   'https://g.ezoic.net',                    true],
+      ['dns-prefetch', 'https://g.ezoic.net',                    false],
+      ['preconnect',   'https://go.ezoic.net',                   true],
+      ['preconnect',   'https://securepubads.g.doubleclick.net', true],
+      ['dns-prefetch', 'https://securepubads.g.doubleclick.net', false],
+      ['preconnect',   'https://pagead2.googlesyndication.com',  true],
+    ]) {
+      const k = rel + href;
+      if (_warmed.has(k)) continue;
+      _warmed.add(k);
+      const l = document.createElement('link');
+      l.rel = rel; l.href = href;
+      if (cors) l.crossOrigin = 'anonymous';
+      head.appendChild(l);
+    }
+  }
+
+  // ─── Ezoic bridge ────────────────────────────────────────────────────────────
+  // Patch showAds so it silently skips IDs whose placeholder is not in the DOM.
+
+  function patchShowAds() {
+    const patch = () => {
+      try {
+        const ez = window.ezstandalone = window.ezstandalone || {};
+        if (window.__nbbEzoicPatched || typeof ez.showAds !== 'function') return;
+        window.__nbbEzoicPatched = true;
+        const orig = ez.showAds;
+        ez.showAds = function (...args) {
+          if (isBlocked()) return;
+          const ids = 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 || seen.has(id)) continue;
+            const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
+            if (!ph || !ph.isConnected) continue;
+            seen.add(id);
+            try { orig.call(ez, id); } catch (e) {}
+          }
+        };
+      } catch (e) {}
+    };
+    patch();
+    if (!window.__nbbEzoicPatched) {
+      try {
+        (window.ezstandalone = window.ezstandalone || {}).cmd =
+          window.ezstandalone.cmd || [];
+        window.ezstandalone.cmd.push(patch);
+      } catch (e) {}
+    }
+  }
+
+  // ─── Config ──────────────────────────────────────────────────────────────────
+
+  async function fetchConfig() {
+    if (st.cfg) return st.cfg;
     try {
-      if (!wrap || !wrap.querySelector) return;
+      const r = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
+      if (r.ok) st.cfg = await r.json();
+    } catch (e) {}
+    return st.cfg;
+  }
+
+  function initPools(cfg) {
+    if (!cfg) return;
+    if (!st.pools.topic.length)    st.pools.topic    = parsePool(cfg.placeholderIds);
+    if (!st.pools.post.length)     st.pools.post     = parsePool(cfg.messagePlaceholderIds);
+    if (!st.pools.category.length) st.pools.category = parsePool(cfg.categoryPlaceholderIds);
+  }
+
+  // ─── Ezoic min-height tightener ──────────────────────────────────────────────
+  // Ezoic injects `min-height:400px !important` via inline style; we override it.
+
+  function tightenMinHeight(wrap) {
+    try {
+      if (!wrap) return;
       const iframes = wrap.querySelectorAll('iframe');
       if (!iframes.length) return;
 
-      let refNode = null;
+      // Find the nearest ezoic-ad ancestor with the 400px inline min-height.
+      let ref = null;
       let p = iframes[0].parentElement;
       while (p && p !== wrap) {
         if (p.classList && p.classList.contains('ezoic-ad')) {
           const st = (p.getAttribute('style') || '').toLowerCase();
-          if (st.includes('min-height:400') || st.includes('min-height: 400')) { refNode = p; break; }
+          if (st.includes('min-height:400') || st.includes('min-height: 400')) { ref = p; break; }
         }
         p = p.parentElement;
       }
-      if (!refNode) refNode = wrap.querySelector('.ezoic-ad-adaptive') || wrap.querySelector('.ezoic-ad') || wrap;
+      ref = ref || wrap.querySelector('.ezoic-ad-adaptive, .ezoic-ad') || wrap;
 
       let refTop = 0;
-      try { refTop = refNode.getBoundingClientRect().top; } catch (e) {}
+      try { refTop = ref.getBoundingClientRect().top; } catch (e) {}
 
-      let maxBottom = 0;
-      iframes.forEach((f) => {
-        const rect = f.getBoundingClientRect();
-        if (rect.width <= 1 || rect.height <= 1) return;
-        maxBottom = Math.max(maxBottom, rect.bottom - refTop);
+      let maxH = 0;
+      iframes.forEach(f => {
+        const r = f.getBoundingClientRect();
+        if (r.width > 1 && r.height > 1) maxH = Math.max(maxH, r.bottom - refTop);
       });
-      if (!maxBottom) {
-        iframes.forEach((f) => {
-          maxBottom = Math.max(maxBottom, parseInt(f.getAttribute('height') || '0', 10), f.offsetHeight || 0);
-        });
-      }
-      if (!maxBottom) return;
+      if (!maxH) iframes.forEach(f => {
+        maxH = Math.max(maxH,
+          parseInt(f.getAttribute('height') || '0', 10), f.offsetHeight || 0);
+      });
+      if (!maxH) return;
 
-      const h = Math.max(1, Math.ceil(maxBottom));
-      const tightenNode = (n) => {
+      const h = Math.max(1, Math.ceil(maxH)) + 'px';
+      const set = (n) => {
         if (!n || !n.style) return;
-        try { n.style.setProperty('min-height', h + 'px', 'important'); } catch (e) { n.style.minHeight = h + 'px'; }
+        try { n.style.setProperty('min-height', h, 'important'); } catch (e) { n.style.minHeight = h; }
         try { n.style.setProperty('height', 'auto', 'important'); } catch (e) {}
         try { n.style.setProperty('line-height', '0', 'important'); } catch (e) {}
       };
 
-      let cur = refNode;
+      let cur = ref;
       while (cur && cur !== wrap) {
         if (cur.classList && cur.classList.contains('ezoic-ad')) {
-          const st = (cur.getAttribute('style') || '').toLowerCase();
-          if (st.includes('min-height:400') || st.includes('min-height: 400')) tightenNode(cur);
+          const s = (cur.getAttribute('style') || '').toLowerCase();
+          if (s.includes('min-height:400') || s.includes('min-height: 400')) set(cur);
         }
         cur = cur.parentElement;
       }
-      tightenNode(refNode);
-      refNode.querySelectorAll('.ezoic-ad[style*="min-height"], .ezoic-ad-adaptive').forEach((n) => {
-        const st = (n.getAttribute('style') || '').toLowerCase();
-        if (st.includes('min-height:400') || st.includes('min-height: 400')) tightenNode(n);
+      set(ref);
+      ref.querySelectorAll('.ezoic-ad[style*="min-height"], .ezoic-ad-adaptive').forEach(n => {
+        const s = (n.getAttribute('style') || '').toLowerCase();
+        if (s.includes('min-height:400') || s.includes('min-height: 400')) set(n);
       });
+
       if (isMobile()) {
-        try { refNode.style.setProperty('width',     '100%', 'important'); } catch (e) {}
-        try { refNode.style.setProperty('max-width', '100%', 'important'); } catch (e) {}
-        try { refNode.style.setProperty('min-width', '0',    'important'); } catch (e) {}
+        try { ref.style.setProperty('width',     '100%', 'important'); } catch (e) {}
+        try { ref.style.setProperty('max-width', '100%', 'important'); } catch (e) {}
+        try { ref.style.setProperty('min-width', '0',    'important'); } catch (e) {}
       }
     } catch (e) {}
   }
 
-  function watchWrapForFill(wrap) {
+  function watchFill(wrap) {
     try {
       if (!wrap || wrap.__ezFillObs) return;
       const start = now();
-      const tightenBurst = () => {
-        try { tightenEzoicMinHeight(wrap); } catch (e) {}
-        if (now() - start < 6000) setTimeout(tightenBurst, 350);
+      const burst = () => {
+        try { tightenMinHeight(wrap); } catch (e) {}
+        if (now() - start < 6000) setTimeout(burst, 350);
       };
-      const obs = new MutationObserver((muts) => {
-        if (isFilled(wrap)) { wrap.classList.remove('is-empty'); tightenBurst(); }
-        for (const m of muts) {
-          if (m.type === 'attributes' && m.attributeName === 'style') {
-            try { tightenEzoicMinHeight(wrap); } catch (e) {}
-            break;
-          }
-        }
-        if (now() - start > 7000) { try { obs.disconnect(); } catch (e) {} wrap.__ezFillObs = null; }
+      const obs = new MutationObserver(muts => {
+        if (isFilled(wrap)) { wrap.classList.remove('is-empty'); burst(); }
+        for (const m of muts)
+          if (m.type === 'attributes' && m.attributeName === 'style') { tightenMinHeight(wrap); break; }
+        if (now() - start > 7000) { obs.disconnect(); wrap.__ezFillObs = null; }
       });
       obs.observe(wrap, { childList: true, subtree: true, attributes: true, attributeFilter: ['style'] });
       wrap.__ezFillObs = obs;
     } catch (e) {}
   }
 
-  function globalGapFixInit() {
+  // Global safety net: catch Ezoic 400px min-height inside posts.
+  function globalGapFix() {
     try {
-      if (window.__nodebbEzoicGapFix) return;
-      window.__nodebbEzoicGapFix = true;
+      if (window.__nbbEzoicGapFix) return;
+      window.__nbbEzoicGapFix = true;
       const root = document.getElementById('content') ||
         document.querySelector('[component="content"], #panel') || document.body;
-      const inPostArea = (el) => {
-        try { return !!(el && el.closest && el.closest('[component="post"], .topic, .posts, [component="topic"]')); }
-        catch (e) { return false; }
-      };
-      const maybeFix = (r) => {
+      const inPost = el => !!(el && el.closest &&
+        el.closest('[component="post"], .topic, .posts, [component="topic"]'));
+      const fix = r => {
         if (!r || !r.querySelectorAll) return;
         r.querySelectorAll('.ezoic-ad[style*="min-height"], .ezoic-ad-adaptive[style*="min-height"]')
-          .forEach((n) => {
-            const st = (n.getAttribute('style') || '').toLowerCase();
-            if (!st.includes('min-height:400')) return;
-            if (!inPostArea(n)) return;
-            try { tightenEzoicMinHeight(n.closest('.' + WRAP_CLASS) || n.parentElement || n); } catch (e) {}
+          .forEach(n => {
+            if (!(n.getAttribute('style') || '').toLowerCase().includes('min-height:400')) return;
+            if (!inPost(n)) return;
+            tightenMinHeight(n.closest('.' + WRAP_CLASS) || n.parentElement || n);
           });
       };
-      requestAnimationFrame(() => maybeFix(root));
+      requestAnimationFrame(() => fix(root));
       const pending = new Set();
-      let scheduled = false;
-      const flush = () => {
-        scheduled = false;
-        pending.forEach((n) => { try { maybeFix(n); } catch (e) {} });
-        pending.clear();
-      };
-      new MutationObserver((muts) => {
+      let sched = false;
+      new MutationObserver(muts => {
         for (const m of muts) {
-          if (m.type === 'attributes') {
-            const t = m.target && m.target.nodeType === 1 ? m.target : m.target && m.target.parentElement;
-            if (t) pending.add(t);
-          } else if (m.addedNodes) {
-            m.addedNodes.forEach((n) => { if (n && n.nodeType === 1) pending.add(n); });
-          }
+          const t = m.type === 'attributes'
+            ? (m.target.nodeType === 1 ? m.target : m.target.parentElement)
+            : null;
+          if (t) pending.add(t);
+          else m.addedNodes && m.addedNodes.forEach(n => n.nodeType === 1 && pending.add(n));
+        }
+        if (pending.size && !sched) {
+          sched = true;
+          requestAnimationFrame(() => { sched = false; pending.forEach(n => fix(n)); pending.clear(); });
         }
-        if (pending.size && !scheduled) { scheduled = true; requestAnimationFrame(flush); }
       }).observe(root, { subtree: true, childList: true, attributes: true, attributeFilter: ['style'] });
     } catch (e) {}
   }
 
-  // ─── State ──────────────────────────────────────────────────────────────────
-  const state = {
-    pageKey: null, cfg: null,
-    allTopics: [], allPosts: [], allCategories: [],
-    curTopics: 0, curPosts: 0, curCategories: 0,
-    lastShowById: new Map(),
-    domObs: null, io: null, ioMargin: null,
-    internalDomChange: 0,
-    inflight: 0, pending: [], pendingSet: new Set(),
-    scrollBoostUntil: 0, lastScrollY: 0, lastScrollTs: 0,
-    heroDoneForPage: false,
-    runQueued: false, burstActive: false, burstDeadline: 0, burstCount: 0, lastBurstReqTs: 0,
-  };
-
-  let blockedUntil = 0;
-  const insertingIds = new Set();
-  function isBlocked() { return now() < blockedUntil; }
-
-  // ─── Utils ──────────────────────────────────────────────────────────────────
-  function parsePool(raw) {
-    if (!raw) return [];
-    const seen = new Set(), out = [];
-    String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean).forEach((v) => {
-      const n = parseInt(v, 10);
-      if (Number.isFinite(n) && n > 0 && !seen.has(n)) { seen.add(n); out.push(n); }
-    });
-    return out;
-  }
-
-  function getPageKey() {
-    try {
-      const ax = window.ajaxify;
-      if (ax && ax.data) {
-        if (ax.data.tid) return 'topic:' + ax.data.tid;
-        if (ax.data.cid) return 'cid:' + ax.data.cid + ':' + window.location.pathname;
-      }
-    } catch (e) {}
-    return window.location.pathname;
-  }
+  // ─── DOM helpers ─────────────────────────────────────────────────────────────
 
-  function getPreloadRootMargin() {
-    return isMobile()
-      ? (isBoosted() ? PRELOAD_MARGIN_MOBILE_BOOST  : PRELOAD_MARGIN_MOBILE)
-      : (isBoosted() ? PRELOAD_MARGIN_DESKTOP_BOOST : PRELOAD_MARGIN_DESKTOP);
-  }
-
-  function getMaxInflight() {
-    return (isMobile() ? MAX_INFLIGHT_MOBILE : MAX_INFLIGHT_DESKTOP) + (isBoosted() ? 1 : 0);
-  }
-
-  function withInternalDomChange(fn) {
-    state.internalDomChange++;
-    try { fn(); } finally { state.internalDomChange--; }
-  }
-
-  // ─── DOM helpers ────────────────────────────────────────────────────────────
-  function getTopicItems()    { return Array.from(document.querySelectorAll(SELECTORS.topicItem)); }
-  function getCategoryItems() { return Array.from(document.querySelectorAll(SELECTORS.categoryItem)); }
-
-  function getPostContainers() {
-    return Array.from(document.querySelectorAll(SELECTORS.postItem)).filter((el) => {
+  function getItems(kind) {
+    if (kind === 'topic')         return Array.from(document.querySelectorAll(SEL.post)).filter(el => {
       if (!el.isConnected) return false;
       if (!el.querySelector('[component="post/content"]')) return false;
-      const pp = el.parentElement && el.parentElement.closest('[component="post"][data-pid]');
-      if (pp && pp !== el) return false;
-      if (el.getAttribute('component') === 'post/parent') return false;
-      return true;
+      const pp = el.parentElement && el.parentElement.closest(SEL.post);
+      return !(pp && pp !== el) && el.getAttribute('component') !== 'post/parent';
     });
+    if (kind === 'categoryTopics') return Array.from(document.querySelectorAll(SEL.topic));
+    if (kind === 'categories')     return Array.from(document.querySelectorAll(SEL.category));
+    return [];
   }
 
-  function getKind() {
-    const p = window.location.pathname || '';
-    if (/^\/topic\//.test(p))              return 'topic';
-    if (/^\/category\//.test(p))           return 'categoryTopics';
-    if (p === '/' || /^\/categories/.test(p)) return 'categories';
-    if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
-    if (document.querySelector(SELECTORS.postItem))     return 'topic';
-    if (document.querySelector(SELECTORS.topicItem))    return 'categoryTopics';
-    return 'other';
-  }
-
-  function isAdjacentAd(target) {
-    if (!target) return false;
-    const next = target.nextElementSibling;
-    if (next && next.classList && next.classList.contains(WRAP_CLASS)) return true;
-    const prev = target.previousElementSibling;
-    if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) return true;
-    return false;
-  }
-
-  function findWrap(kindClass, afterPos) {
-    return document.querySelector('.' + WRAP_CLASS + '.' + kindClass + '[data-ezoic-after="' + afterPos + '"]');
-  }
-
-  // ─── Network warmup ─────────────────────────────────────────────────────────
-  const _warmLinksDone = new Set();
-  function warmUpNetwork() {
-    try {
-      const head = document.head || document.getElementsByTagName('head')[0];
-      if (!head) return;
-      [
-        ['preconnect',   'https://g.ezoic.net',                     true],
-        ['dns-prefetch', 'https://g.ezoic.net',                     false],
-        ['preconnect',   'https://go.ezoic.net',                    true],
-        ['dns-prefetch', 'https://go.ezoic.net',                    false],
-        ['preconnect',   'https://securepubads.g.doubleclick.net',  true],
-        ['dns-prefetch', 'https://securepubads.g.doubleclick.net',  false],
-        ['preconnect',   'https://pagead2.googlesyndication.com',   true],
-        ['dns-prefetch', 'https://pagead2.googlesyndication.com',   false],
-        ['preconnect',   'https://tpc.googlesyndication.com',       true],
-        ['dns-prefetch', 'https://tpc.googlesyndication.com',       false],
-      ].forEach(([rel, href, cors]) => {
-        const key = rel + '|' + href;
-        if (_warmLinksDone.has(key)) return;
-        _warmLinksDone.add(key);
-        const link = document.createElement('link');
-        link.rel = rel; link.href = href;
-        if (cors) link.crossOrigin = 'anonymous';
-        head.appendChild(link);
-      });
-    } catch (e) {}
-  }
-
-  // ─── Ezoic bridge ───────────────────────────────────────────────────────────
-  // Patch showAds so it silently skips IDs whose placeholder is not in the DOM.
-  function patchShowAds() {
-    const applyPatch = () => {
-      try {
-        window.ezstandalone = window.ezstandalone || {};
-        const ez = window.ezstandalone;
-        if (window.__nodebbEzoicPatched) return;
-        if (typeof ez.showAds !== 'function') return;
-        window.__nodebbEzoicPatched = true;
-        const orig = ez.showAds;
-        ez.showAds = function (...args) {
-          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 || seen.has(id)) continue;
-            const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
-            if (!ph || !ph.isConnected) continue;
-            seen.add(id);
-            try { orig.call(ez, id); } catch (e) {}
-          }
-        };
-      } catch (e) {}
-    };
-    applyPatch();
-    if (!window.__nodebbEzoicPatched) {
-      try {
-        window.ezstandalone = window.ezstandalone || {};
-        window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-        window.ezstandalone.cmd.push(applyPatch);
-      } catch (e) {}
-    }
-  }
-
-  // ─── Config ─────────────────────────────────────────────────────────────────
-  async function fetchConfigOnce() {
-    if (state.cfg) return state.cfg;
-    try {
-      const res = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
-      if (!res.ok) return null;
-      state.cfg = await res.json();
-      return state.cfg;
-    } catch (e) { return null; }
+  function isAdjacentWrap(el) {
+    const n = el.nextElementSibling,  p = el.previousElementSibling;
+    return (n && n.classList.contains(WRAP_CLASS)) || (p && p.classList.contains(WRAP_CLASS));
   }
 
-  function initPools(cfg) {
-    if (!cfg) return;
-    // Pools are NOT pre-seeded into the DOM: connecting placeholders offscreen
-    // causes Ezoic to pre-define slots → "already defined" errors on SPA navigations.
-    if (!state.allTopics.length)     state.allTopics     = parsePool(cfg.placeholderIds);
-    if (!state.allPosts.length)      state.allPosts      = parsePool(cfg.messagePlaceholderIds);
-    if (!state.allCategories.length) state.allCategories = parsePool(cfg.categoryPlaceholderIds);
+  function findWrapAt(kindClass, afterPos) {
+    return document.querySelector('.' + WRAP_CLASS + '.' + kindClass +
+      '[data-ezoic-after="' + afterPos + '"]');
   }
 
-  // ─── Insertion primitives ───────────────────────────────────────────────────
+  // ─── Wrap creation / destruction ─────────────────────────────────────────────
 
-  function buildWrap(id, kindClass, afterPos, createPlaceholder) {
+  function buildWrap(id, kindClass, afterPos) {
     const wrap = document.createElement('div');
-    wrap.className = WRAP_CLASS + ' ' + kindClass;
+    wrap.className  = WRAP_CLASS + ' ' + kindClass;
     wrap.setAttribute('data-ezoic-after',  String(afterPos));
     wrap.setAttribute('data-ezoic-wrapid', String(id));
     wrap.setAttribute('data-created',      String(now()));
     if (afterPos === 1) wrap.setAttribute('data-ezoic-pin', '1');
     wrap.style.width = '100%';
-    if (createPlaceholder) {
-      const ph = document.createElement('div');
-      ph.id = PLACEHOLDER_PREFIX + id;
-      ph.setAttribute('data-ezoic-id', String(id));
-      wrap.appendChild(ph);
-    }
+    const ph = document.createElement('div');
+    ph.id = PLACEHOLDER_PREFIX + id;
+    ph.setAttribute('data-ezoic-id', String(id));
+    wrap.appendChild(ph);
     return wrap;
   }
 
-  function insertAfter(target, id, kindClass, afterPos) {
-    if (!target || !target.insertAdjacentElement) return null;
-    if (findWrap(kindClass, afterPos)) return null;
-    if (insertingIds.has(id)) return null;
-    const existingPh = document.getElementById(PLACEHOLDER_PREFIX + id);
-    insertingIds.add(id);
-    try {
-      const wrap = buildWrap(id, kindClass, afterPos, !existingPh);
-      target.insertAdjacentElement('afterend', wrap);
-      if (existingPh) {
-        existingPh.setAttribute('data-ezoic-id', String(id));
-        if (!wrap.firstElementChild) wrap.appendChild(existingPh);
-        else wrap.replaceChild(existingPh, wrap.firstElementChild);
-      }
-      return wrap;
-    } finally {
-      insertingIds.delete(id);
-    }
-  }
-
-  function releaseWrapNode(wrap) {
+  function dropWrap(wrap) {
+    // Unobserve placeholder, then remove the whole wrap node.
+    // The placeholder ID is freed back to the pool automatically because
+    // it no longer has a DOM element — pickId will pick it again.
     try {
-      const ph = wrap && wrap.querySelector && wrap.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
-      if (ph) {
-        try { (document.body || document.documentElement).appendChild(ph); } catch (e) {}
-        try { state.io && state.io.unobserve(ph); } catch (e) {}
-      }
+      const ph = wrap.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
+      if (ph) try { st.io && st.io.unobserve(ph); } catch (e) {}
     } catch (e) {}
-    try { wrap && wrap.remove && wrap.remove(); } catch (e) {}
+    try { wrap.remove(); } catch (e) {}
   }
 
-  function pickIdFromAll(allIds, cursorKey) {
-    const n = allIds.length;
-    if (!n) return null;
-    for (let tries = 0; tries < n; tries++) {
-      const idx = state[cursorKey] % n;
-      state[cursorKey] = (state[cursorKey] + 1) % n;
-      const id = allIds[idx];
-      const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
-      // Skip if placeholder is already mounted in a visible wrap.
-      if (ph && ph.isConnected && ph.closest('.' + WRAP_CLASS)) continue;
-      return id;
-    }
-    return null;
+  function getDetachedMap(kindClass) {
+    let m = st.detached.get(kindClass);
+    if (!m) { m = new Map(); st.detached.set(kindClass, m); }
+    return m;
   }
 
-  // ─── Orphan / cluster management ────────────────────────────────────────────
-  function pruneOrphanWraps(kindClass, items) {
-    if (!items || !items.length) return 0;
-    const itemSet      = new Set(items);
-    const isMessage    = kindClass === 'ezoic-ad-message';
-    const allowRelease = isMessage;
-    let removed = 0;
-
-    const hasNearbyItem = (wrap) => {
-      // If wrap is inside a li.nodebb-ezoic-host, check the HOST's siblings.
-      const pivot = (wrap.parentElement && wrap.parentElement.classList &&
-                     wrap.parentElement.classList.contains(HOST_CLASS))
-        ? wrap.parentElement : wrap;
-      let prev = pivot.previousElementSibling;
-      for (let i = 0; i < 14 && prev; i++) {
-        if (itemSet.has(prev)) return true;
-        prev = prev.previousElementSibling;
-      }
-      let next = pivot.nextElementSibling;
-      for (let i = 0; i < 14 && next; i++) {
-        if (itemSet.has(next)) return true;
-        next = next.nextElementSibling;
-      }
-      return false;
-    };
-
-    document.querySelectorAll('.' + WRAP_CLASS + '.' + kindClass).forEach((wrap) => {
-      if (wrap.getAttribute('data-ezoic-pin') === '1') return;
-
-      if (hasNearbyItem(wrap)) {
-        // Anchor is in the DOM → always restore visibility, regardless of age.
-        try { wrap.classList.remove('ez-orphan-hidden'); wrap.style.display = ''; } catch (e) {}
-        return;
-      }
-
-      // Anchor is NOT in the DOM → always hide immediately, regardless of age.
-      // KEY FIX: the previous code skipped this for fresh wraps (< keepEmptyWrapMs).
-      // That meant a wrap whose anchor topic was virtualized away within the first
-      // 60-120s would stay visible and float to the top of the list.
-      try { wrap.classList.add('ez-orphan-hidden'); wrap.style.display = 'none'; } catch (e) {}
-
-      // Release (message-ads only): only after the freshness window, and only
-      // when far off-screen — we still want late-filling ads to have a chance.
-      if (!allowRelease) return;
-
-      const created = parseInt(wrap.getAttribute('data-created') || '0', 10);
-      if (created && (now() - created) < keepEmptyWrapMs()) return;
+  function detachWrap(kindClass, wrap) {
+    // Keep a wrap node in memory so we can re-attach it later without
+    // re-requesting the same placement (avoids GPT "format already created" and
+    // prevents ads from vanishing permanently when NodeBB recycles DOM nodes).
+    try {
+      const afterPos = parseInt(wrap.getAttribute('data-ezoic-after') || '0', 10);
+      if (!afterPos) return dropWrap(wrap);
 
+      // Unobserve placeholder while detached
       try {
-        const r  = wrap.getBoundingClientRect();
-        const vh = Math.max(1, window.innerHeight || 1);
-        if (r.bottom > -vh * 2 && r.top < vh * 4) return;
-      } catch (e) { return; }
-
-      withInternalDomChange(() => releaseWrapNode(wrap));
-      removed++;
-    });
-    return removed;
-  }
+        const ph = wrap.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
+        if (ph) try { st.io && st.io.unobserve(ph); } catch (e) {}
+      } catch (e) {}
 
-  function decluster(kindClass) {
-    const wraps = Array.from(document.querySelectorAll('.' + WRAP_CLASS + '.' + kindClass));
-    if (wraps.length < 2) return 0;
-    // Between/category ads: hide the duplicate rather than releasing it.
-    // Releasing frees IDs into the pool → re-injection at wrong positions on scroll-up.
-    const allowRelease = kindClass === 'ezoic-ad-message';
-    const evict = (n) => {
-      if (allowRelease) { withInternalDomChange(() => releaseWrapNode(n)); }
-      else { try { n.classList.add('ez-orphan-hidden'); n.style.display = 'none'; } catch (e) {} }
-    };
-    const isWrap  = (el) => !!(el && el.classList && el.classList.contains(WRAP_CLASS));
-    const isFresh = (w)  => {
-      const c = parseInt(w.getAttribute('data-created') || '0', 10);
-      return c && (now() - c) < keepEmptyWrapMs();
-    };
-    let removed = 0;
-    for (const w of wraps) {
-      if (w.getAttribute && w.getAttribute('data-ezoic-pin') === '1') continue;
-      if (w.classList && w.classList.contains('ez-orphan-hidden')) continue;
-      let prev = w.previousElementSibling;
-      for (let i = 0; i < 3 && prev; i++) {
-        if (isWrap(prev)) {
-          if (prev.getAttribute && prev.getAttribute('data-ezoic-pin') === '1') break;
-          if (prev.classList && prev.classList.contains('ez-orphan-hidden')) break;
-          const prevFilled = isFilled(prev);
-          const curFilled  = isFilled(w);
-          if (curFilled) {
-            if (!prevFilled && !isFresh(prev)) { evict(prev); removed++; }
-            break;
-          }
-          if (prevFilled || !isFresh(w)) { evict(w); removed++; }
-          break;
-        }
-        prev = prev.previousElementSibling;
+      const m = getDetachedMap(kindClass);
+      // If a cached wrap for that position already exists, prefer the newest
+      // and fully drop the old one.
+      if (m.has(afterPos)) {
+        try { dropWrap(m.get(afterPos)); } catch (e) {}
       }
-    }
-    return removed;
-  }
-
-  // ─── Pile-up repair for between-ads ─────────────────────────────────────────
-  // When NodeBB's DOM structure requires between-ad DIVs to live inside a <ul>,
-  // they must be wrapped in a <li> host. This module also corrects position
-  // drift that occurs after infinite-scroll mutations.
-  //
-  // FIX (v18): replaced the previous blind `previousTopicLi()` DOM walk with
-  // anchor lookup via `data-ezoic-after` + topic `data-index`. The old approach
-  // was the ROOT CAUSE of ads piling below the first topic: during pile-up
-  // detection it moved ALL piled wraps to after the SAME first topic it found.
-  //
-  // Now each wrap is moved to after the specific topic whose ordinal matches
-  // the wrap's own `data-ezoic-after` attribute.
-
-  function pileFixGetTopicList() {
-    try {
-      const li = document.querySelector(SELECTORS.topicItem);
-      if (!li) return null;
-      return li.closest ? li.closest('ul,ol') : null;
-    } catch (e) { return null; }
-  }
-
-  function ensureHostForWrap(wrap, ul) {
-    try {
-      if (!wrap || wrap.nodeType !== 1) return null;
-      const wrapSel = 'div.' + WRAP_CLASS + '.ezoic-ad-between';
-      if (!wrap.matches || !wrap.matches(wrapSel)) return null;
-      const existing = wrap.closest ? wrap.closest('li.' + HOST_CLASS) : null;
-      if (existing) return existing;
-      if (!ul) ul = wrap.closest ? wrap.closest('ul,ol') : null;
-      if (!ul || !/^(UL|OL)$/i.test(ul.tagName)) return null;
-      if (wrap.parentElement !== ul) return null;
-      const host = document.createElement('li');
-      host.className = HOST_CLASS;
-      host.setAttribute('role', 'listitem');
-      host.style.cssText = 'list-style:none;width:100%;';
-      ul.insertBefore(host, wrap);
-      host.appendChild(wrap);
-      return host;
-    } catch (e) { return null; }
-  }
-
-  function detectPileUp(ul) {
-    try {
-      let run = 0, maxRun = 0;
-      const kids = ul.children;
-      const wrapSel = 'div.' + WRAP_CLASS + '.ezoic-ad-between';
-      for (let i = 0; i < kids.length; i++) {
-        const el = kids[i];
-        const isHost    = el.tagName === 'LI' && el.classList && el.classList.contains(HOST_CLASS);
-        const isBetween = (isHost && el.querySelector && el.querySelector(wrapSel)) ||
-                          (el.matches && el.matches(wrapSel));
-        if (isBetween)                              { maxRun = Math.max(maxRun, ++run); }
-        else if (el.matches && el.matches(SELECTORS.topicItem)) { run = 0; }
-        else                                        { run = 0; }
+      m.set(afterPos, wrap);
+
+      // Hard cap cache size per kind to avoid unbounded memory growth.
+      if (m.size > 80) {
+        const oldest = [...m.entries()].sort((a, b) => {
+          const ta = parseInt((a[1] && a[1].getAttribute('data-created')) || '0', 10);
+          const tb = parseInt((b[1] && b[1].getAttribute('data-created')) || '0', 10);
+          return ta - tb;
+        }).slice(0, m.size - 80);
+        oldest.forEach(([pos, node]) => {
+          m.delete(pos);
+          try { dropWrap(node); } catch (e) {}
+        });
       }
-      return maxRun >= 2;
-    } catch (e) { return false; }
-  }
-
-  /**
-   * Move each pile-up host to after its correct anchor topic.
-   *
-   * Anchor is determined by matching the wrap's `data-ezoic-after` (1-based ordinal)
-   * against each topic LI's `data-index` (0-based) → ordinal = data-index + 1.
-   */
-  function redistributePileUp(ul) {
-    try {
-      if (!ul) return;
-      // Step 1: wrap bare between-ad DIVs that are direct <ul> children.
-      const wrapSel = 'div.' + WRAP_CLASS + '.ezoic-ad-between';
-      const directs = Array.from(ul.querySelectorAll(':scope > ' + wrapSel));
-      directs.forEach((w) => ensureHostForWrap(w, ul));
-
-      // Step 2: bail if no pile-up.
-      if (!detectPileUp(ul)) return;
-
-      // Step 3: build ordinal → topic LI map.
-      const topicLis = Array.from(ul.querySelectorAll(':scope > ' + SELECTORS.topicItem));
-      const ordinalMap = new Map();
-      topicLis.forEach((li, i) => {
-        const di  = li.dataset && (li.dataset.index !== undefined ? li.dataset.index : null);
-        const raw = di !== null && di !== undefined ? di : li.getAttribute('data-index');
-        const ord = (raw !== null && raw !== undefined && raw !== '' && !isNaN(raw))
-          ? parseInt(raw, 10) + 1   // data-index is 0-based; ordinals are 1-based
-          : i + 1;
-        ordinalMap.set(ord, li);
-      });
-
-      // Step 4: move each host to immediately after its correct anchor topic.
-      const hosts = Array.from(ul.querySelectorAll(':scope > li.' + HOST_CLASS));
-      hosts.forEach((host) => {
-        try {
-          const wrap = host.querySelector && host.querySelector(wrapSel);
-          if (!wrap) return;
 
-          const afterPos = parseInt(wrap.getAttribute('data-ezoic-after') || '0', 10);
-          if (!afterPos) return;
-
-          const anchor = ordinalMap.get(afterPos);
-          if (!anchor) return; // anchor topic not loaded yet — leave in place
-
-          if (host.previousElementSibling !== anchor) {
-            anchor.insertAdjacentElement('afterend', host);
-          }
-        } catch (e) {}
-      });
-    } catch (e) {}
-  }
-
-  let _pileFixScheduled = false;
-  let _pileFixLastRun   = 0;
-  const PILE_FIX_COOLDOWN = 180;
-
-  function schedulePileFix() {
-    if (now() - _pileFixLastRun < PILE_FIX_COOLDOWN) return;
-    if (_pileFixScheduled) return;
-    _pileFixScheduled = true;
-    requestAnimationFrame(() => {
-      _pileFixScheduled = false;
-      _pileFixLastRun   = now();
-      try { const ul = pileFixGetTopicList(); if (ul) redistributePileUp(ul); } catch (e) {}
-    });
+      // Actually detach from DOM
+      try { wrap.remove(); } catch (e) {}
+    } catch (e) {
+      try { dropWrap(wrap); } catch (x) {}
+    }
   }
 
-  function initPileFixObserver() {
-    try {
-      if (typeof MutationObserver === 'undefined') return;
-      const observe = (ul) => {
-        new MutationObserver(() => schedulePileFix())
-          .observe(ul, { childList: true, subtree: true });
-      };
-      const ul = pileFixGetTopicList();
-      if (ul) {
-        observe(ul);
-      } else {
-        const sentinel = new MutationObserver(() => {
-          const u = pileFixGetTopicList();
-          if (u) { try { sentinel.disconnect(); } catch (e) {} observe(u); }
-        });
-        sentinel.observe(document.documentElement || document.body, { childList: true, subtree: true });
-      }
-    } catch (e) {}
+  function pickId(poolKey, cursorKey) {
+    const pool = st.pools[poolKey];
+    if (!pool.length) return null;
+    const n = pool.length;
+    for (let tries = 0; tries < n; tries++) {
+      const idx = st.cursors[cursorKey] % n;
+      st.cursors[cursorKey] = (idx + 1) % n;
+      const id  = pool[idx];
+      const ph  = document.getElementById(PLACEHOLDER_PREFIX + id);
+      // ID is available if its placeholder is absent from DOM or is floating detached.
+      if (!ph || !ph.isConnected || !ph.closest('.' + WRAP_CLASS)) return id;
+    }
+    return null; // all IDs currently mounted
   }
 
-  // ─── IntersectionObserver (preload / fast fill) ─────────────────────────────
-  function ensurePreloadObserver() {
-    const desiredMargin = getPreloadRootMargin();
-    if (state.io && state.ioMargin === desiredMargin) return state.io;
-
-    try { state.io && state.io.disconnect(); } catch (e) {}
-    state.io = null;
+  // ─── IntersectionObserver ────────────────────────────────────────────────────
 
+  function ensureIO() {
+    const margin = getIoMargin();
+    if (st.io && st.ioMargin === margin) return st.io;
+    try { st.io && st.io.disconnect(); } catch (e) {}
+    st.io = null;
     try {
-      state.io = new IntersectionObserver((entries) => {
-        for (const ent of entries) {
-          if (!ent.isIntersecting) continue;
-          const el = ent.target;
-          try { state.io && state.io.unobserve(el); } catch (e) {}
-          const id = parseInt(el && el.getAttribute && el.getAttribute('data-ezoic-id'), 10);
-          if (Number.isFinite(id) && id > 0) enqueueShow(id);
+      st.io = new IntersectionObserver(entries => {
+        for (const e of entries) {
+          if (!e.isIntersecting) continue;
+          try { st.io && st.io.unobserve(e.target); } catch (x) {}
+          const id = parseInt(e.target.getAttribute('data-ezoic-id'), 10);
+          if (id > 0) enqueueShow(id);
         }
-      }, { root: null, rootMargin: desiredMargin, threshold: 0 });
-      state.ioMargin = desiredMargin;
+      }, { rootMargin: margin, threshold: 0 });
+      st.ioMargin = margin;
+      // Re-observe all live placeholders.
       document.querySelectorAll('[id^="' + PLACEHOLDER_PREFIX + '"]')
-        .forEach((n) => { try { state.io.observe(n); } catch (e) {} });
-    } catch (e) { state.io = state.ioMargin = null; }
-
-    return state.io;
+        .forEach(ph => { try { st.io.observe(ph); } catch (e) {} });
+    } catch (e) { st.io = st.ioMargin = null; }
+    return st.io;
   }
 
-  function observePlaceholder(id) {
+  function observePh(id) {
     const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
     if (!ph || !ph.isConnected) return;
     ph.setAttribute('data-ezoic-id', String(id));
-    try { const io = ensurePreloadObserver(); io && io.observe(ph); } catch (e) {}
+    try { ensureIO() && ensureIO().observe(ph); } catch (e) {}
+    // Immediate fire if already near viewport.
     try {
       const r = ph.getBoundingClientRect();
-      const mobile  = isMobile(), boosted = isBoosted();
-      const screens = boosted ? (mobile ? 9.0 : 5.0) : (mobile ? 6.0 : 3.0);
-      const minBot  = boosted ? (mobile ? -2600 : -1500) : (mobile ? -1400 : -800);
-      if (r.top < window.innerHeight * screens && r.bottom > minBot) enqueueShow(id);
+      const mob = isMobile(), boost = isBoosted();
+      const scr = boost ? (mob ? 9 : 5) : (mob ? 6 : 3);
+      const bot = boost ? (mob ? -2600 : -1500) : (mob ? -1400 : -800);
+      if (r.top < window.innerHeight * scr && r.bottom > bot) enqueueShow(id);
     } catch (e) {}
   }
 
-  // ─── Show queue ─────────────────────────────────────────────────────────────
+  // ─── Show queue ──────────────────────────────────────────────────────────────
+
   function enqueueShow(id) {
     if (!id || isBlocked()) return;
-    const t = now();
-    if (t - (state.lastShowById.get(id) || 0) < 900) return;
-    const max = getMaxInflight();
-    if (state.inflight >= max) {
-      if (!state.pendingSet.has(id)) { state.pending.push(id); state.pendingSet.add(id); }
+    if (now() - (st.lastShow.get(id) || 0) < 900) return;
+    if (st.inflight >= getMaxInflight()) {
+      if (!st.pendingSet.has(id)) { st.pending.push(id); st.pendingSet.add(id); }
       return;
     }
     startShow(id);
@@ -758,414 +514,452 @@
 
   function drainQueue() {
     if (isBlocked()) return;
-    const max = getMaxInflight();
-    while (state.inflight < max && state.pending.length) {
-      const id = state.pending.shift();
-      state.pendingSet.delete(id);
+    while (st.inflight < getMaxInflight() && st.pending.length) {
+      const id = st.pending.shift();
+      st.pendingSet.delete(id);
       startShow(id);
     }
   }
 
-  function markEmptyWrapper(id) {
-    try {
-      const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
-      if (!ph || !ph.isConnected) return;
-      const wrap = ph.closest && ph.closest('.' + WRAP_CLASS);
-      if (!wrap) return;
-      setTimeout(() => {
-        try {
-          const ph2 = document.getElementById(PLACEHOLDER_PREFIX + id);
-          if (!ph2 || !ph2.isConnected) return;
-          const w2 = ph2.closest && ph2.closest('.' + WRAP_CLASS);
-          if (!w2) return;
-          const created = parseInt(w2.getAttribute('data-created') || '0', 10);
-          if (created && (now() - created) < keepEmptyWrapMs()) return;
-          if (!isFilled(ph2)) { w2.classList.add('is-empty'); watchWrapForFill(w2); }
-          else { w2.classList.remove('is-empty'); tightenEzoicMinHeight(w2); }
-        } catch (e) {}
-      }, 15_000);
-    } catch (e) {}
+  function scheduleMarkEmpty(id) {
+    setTimeout(() => {
+      try {
+        const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
+        if (!ph || !ph.isConnected) return;
+        const w = ph.closest('.' + WRAP_CLASS);
+        if (!w) return;
+        if (isFilled(ph)) { w.classList.remove('is-empty'); tightenMinHeight(w); }
+        else { w.classList.add('is-empty'); watchFill(w); }
+      } catch (e) {}
+    }, 15_000);
   }
 
   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);
+    st.inflight++;
+    let done = false;
+    const finish = () => {
+      if (done) return; done = true;
+      st.inflight = Math.max(0, st.inflight - 1);
       drainQueue();
     };
-    const hardTimer = setTimeout(release, 6500);
+    const timeout = setTimeout(finish, 6500);
+
     requestAnimationFrame(() => {
       try {
         if (isBlocked()) return;
         const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
         if (!ph || !ph.isConnected) return;
-        if (isFilled(ph)) { clearTimeout(hardTimer); release(); return; }
-        const t = now();
-        if (t - (state.lastShowById.get(id) || 0) < 900) return;
-        state.lastShowById.set(id, t);
-        window.ezstandalone = window.ezstandalone || {};
-        const ez = window.ezstandalone;
+        if (isFilled(ph)) { clearTimeout(timeout); finish(); return; }
+        if (now() - (st.lastShow.get(id) || 0) < 900) return;
+        st.lastShow.set(id, now());
+
+        const ez = window.ezstandalone = window.ezstandalone || {};
         const doShow = () => {
           try { ez.showAds(id); } catch (e) {}
-          try { markEmptyWrapper(id); } catch (e) {}
+          scheduleMarkEmpty(id);
           try {
-            const ww = document.getElementById(PLACEHOLDER_PREFIX + id);
-            const w2 = ww && ww.closest && ww.closest('.' + WRAP_CLASS);
-            if (w2) {
-              watchWrapForFill(w2);
-              setTimeout(() => { try { tightenEzoicMinHeight(w2); } catch (e) {} }, 900);
-              setTimeout(() => { try { tightenEzoicMinHeight(w2); } catch (e) {} }, 2200);
+            const w = document.getElementById(PLACEHOLDER_PREFIX + id)
+              ?.closest('.' + WRAP_CLASS);
+            if (w) {
+              watchFill(w);
+              setTimeout(() => tightenMinHeight(w), 900);
+              setTimeout(() => tightenMinHeight(w), 2200);
             }
           } catch (e) {}
-          setTimeout(() => { clearTimeout(hardTimer); release(); }, 650);
+          setTimeout(() => { clearTimeout(timeout); finish(); }, 650);
         };
-        if (Array.isArray(ez.cmd)) { try { ez.cmd.push(doShow); } catch (e) { doShow(); } }
+        if (Array.isArray(ez.cmd)) try { ez.cmd.push(doShow); } catch (e) { doShow(); }
         else doShow();
-      } finally {
-        // hardTimer covers early returns.
-      }
+      } finally {} // timeout covers early returns
     });
   }
 
-  // ─── Core injection ─────────────────────────────────────────────────────────
-  function getItemOrdinal(el, fallbackIndex) {
+  // ─── Core injection ──────────────────────────────────────────────────────────
+
+  function getOrdinal(el, idx) {
     try {
-      if (!el) return fallbackIndex + 1;
-      const di = el.getAttribute('data-index') ||
-                 (el.dataset && (el.dataset.index || el.dataset.postIndex));
-      if (di != null && di !== '' && !isNaN(di)) {
-        const n = parseInt(di, 10);
-        if (Number.isFinite(n) && n >= 0) return n + 1;
-      }
-      const d1 = el.getAttribute('data-idx') || el.getAttribute('data-position') ||
-                 (el.dataset && (el.dataset.idx || el.dataset.position));
-      if (d1 != null && d1 !== '' && !isNaN(d1)) {
-        const n = parseInt(d1, 10);
-        if (Number.isFinite(n) && n > 0) return n;
-      }
+      const v = el.getAttribute('data-index') || (el.dataset && el.dataset.index);
+      if (v != null && v !== '' && !isNaN(v)) return parseInt(v, 10) + 1;
     } catch (e) {}
-    return fallbackIndex + 1;
+    return idx + 1;
   }
 
-  function buildOrdinalMap(items) {
+  function computeTargets(items, interval, showFirst) {
+    // Build ordinal map and determine target positions.
     const map = new Map();
     let max = 0;
-    for (let i = 0; i < items.length; i++) {
-      const ord = getItemOrdinal(items[i], i);
-      map.set(ord, items[i]);
+    items.forEach((el, i) => {
+      const ord = getOrdinal(el, i);
+      map.set(ord, el);
       if (ord > max) max = ord;
-    }
-    return { map, max };
+    });
+    const targets = [];
+    if (showFirst && max >= 1) targets.push(1);
+    for (let i = interval; i <= max; i += interval) targets.push(i);
+    return { map, targets: [...new Set(targets)].sort((a, b) => a - b) };
   }
 
-  function computeTargets(count, interval, showFirst) {
-    const out = [];
-    if (count <= 0) return out;
-    if (showFirst) out.push(1);
-    for (let i = 1; i <= count; i++) { if (i % interval === 0) out.push(i); }
-    return Array.from(new Set(out)).sort((a, b) => a - b);
-  }
+  /**
+   * Remove all wraps whose anchor item is no longer in the live item set.
+   *
+   * Strategy: always fully remove (not just hide).
+   * - The placeholder ID returns to the pool naturally (no DOM element → pickId skips).
+   * - When the user scrolls back down and those items reload, fresh wraps are injected.
+   * - The viewport guard in injectWraps (rect.bottom < 0) prevents re-injection
+   *   on items that are above the fold (just loaded by NodeBB during upward scroll).
+   */
+  function removeOrphanWraps(kindClass, itemSet) {
+    document.querySelectorAll('.' + WRAP_CLASS + '.' + kindClass).forEach(wrap => {
+      if (wrap.getAttribute('data-ezoic-pin') === '1') return;
+
+      // Check if anchor is still alive using DOM proximity.
+      const pivot = (wrap.parentElement && wrap.parentElement.classList.contains(HOST_CLASS))
+        ? wrap.parentElement : wrap;
+      let found = false, el = pivot.previousElementSibling;
+      for (let i = 0; i < 4 && el; i++, el = el.previousElementSibling)
+        if (itemSet.has(el)) { found = true; break; }
+      if (!found) {
+        el = pivot.nextElementSibling;
+        for (let i = 0; i < 4 && el; i++, el = el.nextElementSibling)
+          if (itemSet.has(el)) { found = true; break; }
+      }
 
-  function pickRecyclableWrap(kindClass) {
-    const wraps = document.querySelectorAll('.' + kindClass + '[data-ezoic-wrapid]');
-    if (!wraps || !wraps.length) return null;
-    const vh        = Math.max(300, window.innerHeight || 800);
-    const threshold = -Math.min(9000, Math.round(vh * 6));
-    let best = null, bestBottom = Infinity;
-    for (const w of wraps) {
-      if (!w.isConnected) continue;
-      if (w.getAttribute('data-ezoic-pin') === '1') continue;
-      // FIX: do not recycle near-top wraps (afterPos ≤ 6).
-      // These are likely to be visible again when the user scrolls back up.
-      const afterPos = parseInt(w.getAttribute('data-ezoic-after') || '0', 10);
-      if (afterPos > 0 && afterPos <= 6) continue;
-      const rect = w.getBoundingClientRect();
-      if (rect.bottom < threshold && rect.bottom < bestBottom) {
-        bestBottom = rect.bottom;
-        best = w;
+      if (!found) {
+        // Detach instead of destroy so ads can survive DOM recycling.
+        withInternal(() => detachWrap(kindClass, wrap));
       }
-    }
-    return best;
+    });
   }
 
-  function moveWrapAfter(anchorEl, wrap, kindClass, afterPos) {
+  function reapDetached(kindClass) {
+    // Soft-prune very old detached nodes.
     try {
-      if (!anchorEl || !wrap || !wrap.isConnected) return null;
-      wrap.setAttribute('data-ezoic-after', String(afterPos));
-      anchorEl.insertAdjacentElement('afterend', wrap);
-      try { wrap.style.contain = 'layout style paint'; } catch (e) {}
-      return wrap;
-    } catch (e) { return null; }
+      const m = st.detached.get(kindClass);
+      if (!m || !m.size) return;
+      for (const [pos, wrap] of m.entries()) {
+        if (!wrap) { m.delete(pos); continue; }
+        if (wrap.isConnected) { m.delete(pos); continue; }
+        const created = parseInt(wrap.getAttribute('data-created') || '0', 10);
+        if (created && (now() - created) > 15 * 60 * 1000) {
+          m.delete(pos);
+          try { dropWrap(wrap); } catch (e) {}
+        }
+      }
+    } catch (e) {}
   }
 
-  function injectBetween(kindClass, items, interval, showFirst, allIds, cursorKey) {
+  function injectWraps(kindClass, items, interval, showFirst, poolKey, cursorKey) {
     if (!items.length) return 0;
-    const { map: ordinalMap, max: maxOrdinal } = buildOrdinalMap(items);
-    const targets    = computeTargets(maxOrdinal, interval, showFirst);
-    const maxInserts = MAX_INSERTS_PER_RUN + (isBoosted() ? 1 : 0);
-    let inserted = 0;
+    const { map, targets } = computeTargets(items, interval, showFirst);
+    const max = MAX_INSERTS_PER_RUN + (isBoosted() ? 1 : 0);
+    let n = 0;
 
-    for (const afterPos of targets) {
-      if (inserted >= maxInserts) break;
-      const el = ordinalMap.get(afterPos);
+    const detachedMap = st.detached.get(kindClass);
+
+    for (const pos of targets) {
+      if (n >= max) break;
+      const el = map.get(pos);
       if (!el || !el.isConnected) continue;
 
-      // Never inject after an element that is fully above the viewport top.
-      // This is the definitive guard: NodeBB loads items above the fold when the
-      // user scrolls up. Those items have rect.bottom < 0 at the moment of load.
-      // Any negative margin ("a little above is ok") still causes the pile-up
-      // because NodeBB loads a whole batch just above — we must use exactly 0.
-      try {
-        if (el.getBoundingClientRect().bottom < 0) continue;
-      } catch (e) {}
+      // ── Viewport guard ────────────────────────────────────────────────────────
+      // Never inject after an element whose bottom is above the viewport top.
+      // NodeBB loads items above the fold when the user scrolls up; those items
+      // have rect.bottom < 0 at load time. Injecting there causes the pile-up.
+      try { if (el.getBoundingClientRect().bottom < 0) continue; } catch (e) {}
+
+      if (isAdjacentWrap(el))          continue;
+      if (findWrapAt(kindClass, pos))  continue;
+
+      // If we previously had a wrap at this exact position but NodeBB recycled
+      // the DOM, re-attach the cached wrap instead of creating a new one.
+      if (detachedMap && detachedMap.has(pos)) {
+        const cached = detachedMap.get(pos);
+        detachedMap.delete(pos);
+        if (cached) {
+          withInternal(() => el.insertAdjacentElement('afterend', cached));
+          // Re-observe placeholder and trigger show only if the cached wrap is empty.
+          try {
+            const ph = cached.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
+            const id = ph ? parseInt(ph.getAttribute('data-ezoic-id') || (ph.id || '').split('-').pop(), 10) : 0;
+            if (id > 0) {
+              observePh(id);
+              if (!isFilled(cached)) enqueueShow(id);
+            }
+          } catch (e) {}
+          n++;
+          continue;
+        }
+      }
 
-      if (isAdjacentAd(el)) continue;
-      if (findWrap(kindClass, afterPos)) continue;
+      const id = pickId(poolKey, cursorKey);
+      if (!id) break;
 
-      let id = pickIdFromAll(allIds, cursorKey);
-      let recycledWrap = null;
+      const wrap = buildWrap(id, kindClass, pos);
+      withInternal(() => el.insertAdjacentElement('afterend', wrap));
+      observePh(id);
+      n++;
+    }
+    return n;
+  }
 
-      if (!id) {
-        // Pool exhausted: try to recycle a wrap that is far above the viewport.
-        // Recycling is disabled when scrolling up and for message ads.
-        // Recycling is disabled for between/category ads (we never release those wraps).
-        const allowRecycle = kindClass === 'ezoic-ad-message' && scrollDir > 0;
-        recycledWrap = allowRecycle ? pickRecyclableWrap(kindClass) : null;
-        if (recycledWrap) id = recycledWrap.getAttribute('data-ezoic-wrapid') || '';
-      }
+  // ─── Pile-up fix for category topic lists ────────────────────────────────────
+  // If the skin requires ad divs inside a <ul>, wrap them in <li> hosts and
+  // correct their position after NodeBB re-renders.
 
-      if (!id) break;
+  let _pileFixSched = false, _pileFixLast = 0;
+  function schedulePileFix() {
+    if (now() - _pileFixLast < 180 || _pileFixSched) return;
+    _pileFixSched = true;
+    requestAnimationFrame(() => {
+      _pileFixSched = false; _pileFixLast = now();
+      try {
+        const li = document.querySelector(SEL.topic);
+        const ul = li && li.closest('ul,ol');
+        if (!ul) return;
+
+        // Wrap bare ad divs that are direct <ul> children into <li> hosts.
+        const wrapSel = 'div.' + WRAP_CLASS + '.ezoic-ad-between';
+        ul.querySelectorAll(':scope > ' + wrapSel).forEach(w => {
+          if (w.parentElement !== ul) return;
+          const host = document.createElement('li');
+          host.className = HOST_CLASS;
+          host.setAttribute('role', 'listitem');
+          host.style.cssText = 'list-style:none;width:100%;';
+          ul.insertBefore(host, w);
+          host.appendChild(w);
+        });
 
-      const wrap = recycledWrap
-        ? moveWrapAfter(el, recycledWrap, kindClass, afterPos)
-        : insertAfter(el, id, kindClass, afterPos);
-      if (!wrap) continue;
+        // Detect pile-up: 2+ between-ad hosts adjacent with no topic between them.
+        let run = 0, maxRun = 0;
+        for (const c of ul.children) {
+          const isBetween = (c.tagName === 'LI' && c.classList.contains(HOST_CLASS) &&
+                             c.querySelector(wrapSel)) ||
+                            (c.matches && c.matches(wrapSel));
+          if (isBetween) maxRun = Math.max(maxRun, ++run);
+          else if (c.matches && c.matches(SEL.topic)) run = 0;
+          else run = 0;
+        }
+        if (maxRun < 2) return;
+
+        // Build ordinal → topic LI map.
+        const ordMap = new Map();
+        Array.from(ul.querySelectorAll(':scope > ' + SEL.topic)).forEach((li, i) => {
+          const di = li.dataset && li.dataset.index;
+          const ord = (di != null && di !== '' && !isNaN(di)) ? parseInt(di, 10) + 1 : i + 1;
+          ordMap.set(ord, li);
+        });
 
-      observePlaceholder(id);
-      inserted++;
-    }
-    return inserted;
+        // Move each host to after its correct anchor topic.
+        ul.querySelectorAll(':scope > li.' + HOST_CLASS).forEach(host => {
+          const wrap = host.querySelector(wrapSel);
+          if (!wrap) return;
+          const pos = parseInt(wrap.getAttribute('data-ezoic-after') || '0', 10);
+          const anchor = pos && ordMap.get(pos);
+          if (anchor && host.previousElementSibling !== anchor)
+            anchor.insertAdjacentElement('afterend', host);
+        });
+      } catch (e) {}
+    });
   }
 
-  // ─── runCore ────────────────────────────────────────────────────────────────
+  // ─── runCore ─────────────────────────────────────────────────────────────────
+
   async function runCore() {
     if (isBlocked()) return 0;
     patchShowAds();
-    const cfg = await fetchConfigOnce();
+    const cfg = await fetchConfig();
     if (!cfg || cfg.excluded) return 0;
     initPools(cfg);
 
     const kind = getKind();
     let inserted = 0;
 
-    // When the user is scrolling UP, NodeBB loads content above the viewport.
-    // Injecting new ad wraps at that moment targets those freshly-loaded top items
-    // (low ordinals) and makes ads appear right at the top of the list.
-    // While scrolling up we only restore previously-hidden wraps (pruneOrphanWraps
-    // un-hides them as their anchor posts return) — no new injections.
-    const canInject = scrollDir >= 0;
-
-    if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
-      const items = getPostContainers();
-      pruneOrphanWraps('ezoic-ad-message', items);
-      if (canInject) {
-        inserted += injectBetween('ezoic-ad-message', items,
-          Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
-          normalizeBool(cfg.showFirstMessageAd), state.allPosts, 'curPosts');
-        decluster('ezoic-ad-message');
-      }
-
-    } else if (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
-      const items = getTopicItems();
-      pruneOrphanWraps('ezoic-ad-between', items);
-      if (canInject) {
-        inserted += injectBetween('ezoic-ad-between', items,
-          Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
-          normalizeBool(cfg.showFirstTopicAd), state.allTopics, 'curTopics');
-        decluster('ezoic-ad-between');
-        schedulePileFix();
-      }
-
-    } else if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
-      const items = getCategoryItems();
-      pruneOrphanWraps('ezoic-ad-categories', items);
-      if (canInject) {
-        inserted += injectBetween('ezoic-ad-categories', items,
-          Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
-          normalizeBool(cfg.showFirstCategoryAd), state.allCategories, 'curCategories');
-        decluster('ezoic-ad-categories');
-      }
+    if (kind === 'topic' && normBool(cfg.enableMessageAds)) {
+      const items = getItems('topic');
+      const set   = new Set(items);
+      removeOrphanWraps('ezoic-ad-message', set);
+      reapDetached('ezoic-ad-message');
+      inserted += injectWraps('ezoic-ad-message', items,
+        Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
+        normBool(cfg.showFirstMessageAd), 'post', 'post');
+
+    } else if (kind === 'categoryTopics' && normBool(cfg.enableBetweenAds)) {
+      const items = getItems('categoryTopics');
+      const set   = new Set(items);
+      removeOrphanWraps('ezoic-ad-between', set);
+      reapDetached('ezoic-ad-between');
+      inserted += injectWraps('ezoic-ad-between', items,
+        Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
+        normBool(cfg.showFirstTopicAd), 'topic', 'topic');
+      schedulePileFix();
+
+    } else if (kind === 'categories' && normBool(cfg.enableCategoryAds)) {
+      const items = getItems('categories');
+      const set   = new Set(items);
+      removeOrphanWraps('ezoic-ad-categories', set);
+      reapDetached('ezoic-ad-categories');
+      inserted += injectWraps('ezoic-ad-categories', items,
+        Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
+        normBool(cfg.showFirstCategoryAd), 'category', 'category');
     }
 
     return inserted;
   }
 
-  // ─── Hero ad (first item, early insert) ─────────────────────────────────────
-  async function insertHeroAdEarly() {
-    if (state.heroDoneForPage || isBlocked()) return;
-    const cfg = await fetchConfigOnce();
+  // ─── Hero ad (inject immediately after first item) ───────────────────────────
+
+  async function heroAd() {
+    if (st.heroDone || isBlocked()) return;
+    const cfg = await fetchConfig();
     if (!cfg || cfg.excluded) return;
     initPools(cfg);
 
     const kind = getKind();
-    let items = [], allIds = [], cursorKey = '', kindClass = '', showFirst = false;
-
-    if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
-      items = getPostContainers(); allIds = state.allPosts; cursorKey = 'curPosts';
-      kindClass = 'ezoic-ad-message'; showFirst = normalizeBool(cfg.showFirstMessageAd);
-    } else if (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
-      items = getTopicItems(); allIds = state.allTopics; cursorKey = 'curTopics';
-      kindClass = 'ezoic-ad-between'; showFirst = normalizeBool(cfg.showFirstTopicAd);
-    } else if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
-      items = getCategoryItems(); allIds = state.allCategories; cursorKey = 'curCategories';
-      kindClass = 'ezoic-ad-categories'; showFirst = normalizeBool(cfg.showFirstCategoryAd);
+    let items = [], showFirst = false, poolKey = '', cursorKey = '', kindClass = '';
+
+    if (kind === 'topic' && normBool(cfg.enableMessageAds)) {
+      items = getItems('topic'); showFirst = normBool(cfg.showFirstMessageAd);
+      poolKey = cursorKey = 'post'; kindClass = 'ezoic-ad-message';
+    } else if (kind === 'categoryTopics' && normBool(cfg.enableBetweenAds)) {
+      items = getItems('categoryTopics'); showFirst = normBool(cfg.showFirstTopicAd);
+      poolKey = cursorKey = 'topic'; kindClass = 'ezoic-ad-between';
+    } else if (kind === 'categories' && normBool(cfg.enableCategoryAds)) {
+      items = getItems('categories'); showFirst = normBool(cfg.showFirstCategoryAd);
+      poolKey = cursorKey = 'category'; kindClass = 'ezoic-ad-categories';
     } else { return; }
 
-    if (!items.length || !showFirst) { state.heroDoneForPage = true; return; }
+    if (!items.length || !showFirst) { st.heroDone = true; return; }
 
     const el = items[0];
-    if (!el || !el.isConnected || isAdjacentAd(el)) return;
-    if (findWrap(kindClass, 1)) { state.heroDoneForPage = true; return; }
+    if (!el || !el.isConnected || isAdjacentWrap(el) || findWrapAt(kindClass, 1))
+      { st.heroDone = true; return; }
 
-    const id = pickIdFromAll(allIds, cursorKey);
+    const id = pickId(poolKey, cursorKey);
     if (!id) return;
 
-    const wrap = insertAfter(el, id, kindClass, 1);
-    if (!wrap) return;
-
-    state.heroDoneForPage = true;
-    observePlaceholder(id);
+    const wrap = buildWrap(id, kindClass, 1);
+    withInternal(() => el.insertAdjacentElement('afterend', wrap));
+    st.heroDone = true;
+    observePh(id);
     enqueueShow(id);
-    drainQueue(); // FIX: was calling undefined startShowQueue()
+    drainQueue();
   }
 
-  // ─── Scheduler ──────────────────────────────────────────────────────────────
-  function scheduleRun(delayMs, cb) {
-    if (state.runQueued) return;
-    state.runQueued = true;
+  // ─── Burst scheduler ─────────────────────────────────────────────────────────
+
+  function scheduleRun(delay, cb) {
+    if (st.runQueued) return;
+    st.runQueued = true;
     const run = async () => {
-      state.runQueued = false;
-      const pk = getPageKey();
-      if (state.pageKey && pk !== state.pageKey) return;
-      let inserted = 0;
-      try { inserted = await runCore(); } catch (e) {}
-      try { cb && cb(inserted); } catch (e) {}
+      st.runQueued = false;
+      if (getPageKey() !== st.pageKey) return;
+      let n = 0;
+      try { n = await runCore(); } catch (e) {}
+      try { cb && cb(n); } catch (e) {}
     };
-    const doRun = () => requestAnimationFrame(run);
-    if (delayMs > 0) setTimeout(doRun, delayMs);
-    else doRun();
+    const go = () => requestAnimationFrame(run);
+    delay > 0 ? setTimeout(go, delay) : go();
   }
 
-  function requestBurst() {
+  function burst() {
     if (isBlocked()) return;
     const t = now();
-    if (t - state.lastBurstReqTs < 120) return;
-    state.lastBurstReqTs = t;
-    const pk = getPageKey();
-    state.pageKey = pk;
-    state.burstDeadline = t + 1800;
-    if (state.burstActive) return;
-    state.burstActive = true;
-    state.burstCount  = 0;
+    if (t - st.lastBurstTs < 120) return;
+    st.lastBurstTs = t;
+    const pk = st.pageKey = getPageKey();
+    st.burstDeadline = t + 1800;
+    if (st.burstActive) return;
+    st.burstActive = true;
+    st.burstCount  = 0;
     const step = () => {
-      if (getPageKey() !== pk || isBlocked() || now() > state.burstDeadline || state.burstCount >= 8) {
-        state.burstActive = false; return;
-      }
-      state.burstCount++;
-      scheduleRun(0, (inserted) => {
-        if (!inserted && !state.pending.length) { state.burstActive = false; return; }
-        setTimeout(step, inserted > 0 ? 120 : 220);
+      if (getPageKey() !== pk || isBlocked() ||
+          now() > st.burstDeadline || st.burstCount >= 8)
+        { st.burstActive = false; return; }
+      st.burstCount++;
+      scheduleRun(0, n => {
+        if (!n && !st.pending.length) { st.burstActive = false; return; }
+        setTimeout(step, n > 0 ? 120 : 220);
       });
     };
     step();
   }
 
-  // ─── Lifecycle ──────────────────────────────────────────────────────────────
+  // ─── Lifecycle ───────────────────────────────────────────────────────────────
+
   function cleanup() {
     blockedUntil = now() + 1200;
-    try { document.querySelectorAll('.' + WRAP_CLASS).forEach((el) => releaseWrapNode(el)); } catch (e) {}
-    state.cfg = null;
-    state.allTopics = []; state.allPosts = []; state.allCategories = [];
-    state.curTopics = 0; state.curPosts = 0; state.curCategories = 0;
-    state.lastShowById.clear();
-    state.inflight = 0; state.pending = []; state.pendingSet.clear();
-    state.heroDoneForPage = false;
-    // Observers are intentionally kept alive across ajaxify cycles.
+    try { document.querySelectorAll('.' + WRAP_CLASS).forEach(dropWrap); } catch (e) {}
+    try {
+      for (const m of st.detached.values()) {
+        for (const w of m.values()) try { dropWrap(w); } catch (e) {}
+        m.clear();
+      }
+      st.detached.clear();
+    } catch (e) {}
+    st.cfg       = null;
+    st.pools     = { topic: [], post: [], category: [] };
+    st.cursors   = { topic: 0,  post: 0,  category: 0 };
+    st.lastShow.clear();
+    st.inflight  = 0;
+    st.pending   = []; st.pendingSet.clear();
+    st.heroDone  = false;
+    // IO and domObs kept alive intentionally.
   }
 
-  function shouldReactToMutations(mutations) {
+  function shouldReact(mutations) {
     for (const m of mutations) {
       if (!m.addedNodes || !m.addedNodes.length) continue;
       for (const n of m.addedNodes) {
         if (!n || n.nodeType !== 1) continue;
-        const el = n;
-        if (
-          (el.matches && (
-            el.matches(SELECTORS.postItem) ||
-            el.matches(SELECTORS.topicItem) ||
-            el.matches(SELECTORS.categoryItem)
-          )) ||
-          (el.querySelector && (
-            el.querySelector(SELECTORS.postItem) ||
-            el.querySelector(SELECTORS.topicItem) ||
-            el.querySelector(SELECTORS.categoryItem)
-          ))
-        ) return true;
+        if ((n.matches    && (n.matches(SEL.post)     || n.matches(SEL.topic)    || n.matches(SEL.category))) ||
+            (n.querySelector && (n.querySelector(SEL.post) || n.querySelector(SEL.topic) || n.querySelector(SEL.category))))
+          return true;
       }
     }
     return false;
   }
 
-  function ensureDomObserver() {
-    if (state.domObs) return;
-    state.domObs = new MutationObserver((mutations) => {
-      if (state.internalDomChange > 0 || isBlocked()) return;
-      if (!shouldReactToMutations(mutations)) return;
-      requestBurst();
+  function ensureDomObs() {
+    if (st.domObs) return;
+    st.domObs = new MutationObserver(muts => {
+      if (st.internalMut > 0 || isBlocked()) return;
+      if (shouldReact(muts)) burst();
     });
-    try { state.domObs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
+    try { st.domObs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
   }
 
-  // ─── NodeBB / scroll bindings ────────────────────────────────────────────────
+  // ─── NodeBB event bindings ───────────────────────────────────────────────────
+
   function bindNodeBB() {
     if (!$) return;
-    $(window).off('.ezoicInfinite');
-    $(window).on('action:ajaxify.start.ezoicInfinite', () => { cleanup(); });
-    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
-      state.pageKey = getPageKey();
+    $(window).off('.ezoicNbb');
+    $(window).on('action:ajaxify.start.ezoicNbb',         ()  => cleanup());
+    $(window).on('action:ajaxify.end.ezoicNbb',           ()  => {
+      st.pageKey = getPageKey();
       blockedUntil = 0;
-      muteNoisyConsole(); ensureTcfApiLocator(); warmUpNetwork(); patchShowAds();
-      globalGapFixInit(); ensurePreloadObserver(); ensureDomObserver(); initPileFixObserver();
-      insertHeroAdEarly().catch(() => {});
-      requestBurst();
+      muteConsole(); warmNetwork(); patchShowAds();
+      globalGapFix(); ensureIO(); ensureDomObs();
+      heroAd().catch(() => {});
+      burst();
       setTimeout(schedulePileFix, 80);
       setTimeout(schedulePileFix, 500);
     });
-    $(window).on('action:ajaxify.contentLoaded.ezoicInfinite', () => {
-      if (!isBlocked()) requestBurst();
-    });
+    $(window).on('action:ajaxify.contentLoaded.ezoicNbb', ()  => { if (!isBlocked()) burst(); });
     $(window).on([
       'action:posts.loaded', 'action:topics.loaded', 'action:categories.loaded',
       'action:category.loaded', 'action:topic.loaded', 'action:infiniteScroll.loaded',
-    ].map((e) => e + '.ezoicInfinite').join(' '), () => {
-      if (!isBlocked()) {
-        requestBurst();
-        setTimeout(schedulePileFix, 80);
-        setTimeout(schedulePileFix, 500);
-      }
+    ].map(e => e + '.ezoicNbb').join(' '),            ()  => {
+      if (!isBlocked()) { burst(); setTimeout(schedulePileFix, 80); setTimeout(schedulePileFix, 500); }
     });
     try {
-      require(['hooks'], (hooks) => {
-        if (!hooks || typeof hooks.on !== 'function') return;
-        ['action:ajaxify.end','action:ajaxify.contentLoaded','action:posts.loaded',
-         'action:topics.loaded','action:categories.loaded','action:category.loaded',
-         'action:topic.loaded','action:infiniteScroll.loaded'].forEach((ev) => {
-          try { hooks.on(ev, () => { if (!isBlocked()) requestBurst(); }); } catch (e) {}
-        });
+      require(['hooks'], hooks => {
+        if (typeof hooks.on !== 'function') return;
+        for (const ev of [
+          'action:ajaxify.end', 'action:ajaxify.contentLoaded',
+          'action:posts.loaded', 'action:topics.loaded', 'action:categories.loaded',
+          'action:category.loaded', 'action:topic.loaded', 'action:infiniteScroll.loaded',
+        ]) try { hooks.on(ev, () => { if (!isBlocked()) burst(); }); } catch (e) {}
       });
     } catch (e) {}
   }
@@ -1173,33 +967,35 @@
   function bindScroll() {
     let ticking = false;
     window.addEventListener('scroll', () => {
+      // Fast-scroll boost: widen IO margins.
       try {
-        const t = now(), y = window.scrollY || window.pageYOffset || 0;
-        if (state.lastScrollTs) {
-          const dt = t - state.lastScrollTs;
-          const dy = Math.abs(y - (state.lastScrollY || 0));
-          if (dt > 0 && dy / dt >= BOOST_SPEED_PX_PER_MS) {
-            const wasBoosted = isBoosted();
-            state.scrollBoostUntil = Math.max(state.scrollBoostUntil || 0, t + BOOST_DURATION_MS);
-            if (!wasBoosted) ensurePreloadObserver();
+        const t = now(), y = window.scrollY || 0;
+        if (st.lastScrollTs) {
+          const speed = Math.abs(y - st.lastScrollY) / (t - st.lastScrollTs);
+          if (speed >= BOOST_SPEED_PX_PER_MS) {
+            const was = isBoosted();
+            st.boostUntil = Math.max(st.boostUntil, t + BOOST_DURATION_MS);
+            if (!was) ensureIO();
           }
         }
-        state.lastScrollY = y; state.lastScrollTs = t;
+        st.lastScrollY = y; st.lastScrollTs = t;
       } catch (e) {}
+
       if (ticking) return;
       ticking = true;
-      requestAnimationFrame(() => { ticking = false; requestBurst(); });
+      requestAnimationFrame(() => { ticking = false; burst(); });
     }, { passive: true });
   }
 
   // ─── Boot ────────────────────────────────────────────────────────────────────
-  state.pageKey = getPageKey();
-  muteNoisyConsole(); ensureTcfApiLocator(); warmUpNetwork(); patchShowAds();
-  ensurePreloadObserver(); ensureDomObserver(); initPileFixObserver();
+
+  st.pageKey = getPageKey();
+  muteConsole(); warmNetwork(); patchShowAds();
+  ensureIO(); ensureDomObs();
   bindNodeBB(); bindScroll();
   blockedUntil = 0;
-  insertHeroAdEarly().catch(() => {});
-  requestBurst();
+  heroAd().catch(() => {});
+  burst();
   schedulePileFix();
 
 })();