nodebb-plugin-ezoic-infinite 1.6.70 → 1.6.71

package/public/client.js

@@ -1,195 +1,594 @@
 (function () {
   'use strict';
 
-  // ─── Constants ───────────────────────────────────────────────────────────────
-  const WRAP_CLASS          = 'nodebb-ezoic-wrap';
-  const PLACEHOLDER_PREFIX  = 'ezoic-pub-ad-placeholder-';
-  const HOST_CLASS          = 'nodebb-ezoic-host';
+  // Track scroll direction to avoid aggressive recycling when the user scrolls upward.
+  // Recycling while scrolling up is a common cause of ads "bunching" and a "disappearing too fast" feeling.
+  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) {}
+
+  // NodeBB client context
+  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
+
+  // IMPORTANT: must NOT collide with Ezoic's own markup (they use `.ezoic-ad`).
+  const WRAP_CLASS = 'nodebb-ezoic-wrap';
+  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
+  const POOL_ID = 'nodebb-ezoic-placeholder-pool';
+
+  // Smoothness caps
+  // Limit how many placements we inject per scan pass.
+  // Too low = you end up with only a handful of placeholders after ajaxify.
+  // Too high = jank on very long pages.
   const MAX_INSERTS_PER_RUN = 8;
 
-  // IntersectionObserver preload margins (large = request fills early).
-  const IO_MARGIN_DESKTOP = '2600px 0px 2600px 0px';
-  const IO_MARGIN_MOBILE  = '3200px 0px 3200px 0px';
+  // Keep empty (unfilled) wraps alive for a while. Topics/messages can fill late (auction/CMP).
+  // Pruning too early makes ads look like they "disappear" while scrolling.
+  // Keep empty wraps alive; mobile fills can be slow.
+  function keepEmptyWrapMs() { return isMobile() ? 120000 : 60000; }
+
+  // Preload margins
+  const PRELOAD_MARGIN_DESKTOP = '2600px 0px 2600px 0px';
+  // Mobile: larger preload window so ad fill requests start earlier and
+  // users don't scroll past empty placeholders.
+  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; // ~2200px/s
+
+  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"]',
+  };
+
+  // Production build: debug disabled
+  function dbg() {}
+
+  // Ezoic (and some partner scripts) can be very noisy in console on SPA/Ajaxify setups.
+  // These warnings are not actionable for end-users and can flood the console.
+  // We selectively silence the known spam patterns while keeping other warnings intact.
+  function muteNoisyConsole() {
+    try {
+      if (window.__nodebbEzoicConsoleMuted) return;
+      window.__nodebbEzoicConsoleMuted = true;
+
+      const shouldMute = (args) => {
+        try {
+          if (!args || !args.length) return false;
+          const s0 = typeof args[0] === 'string' ? args[0] : '';
+          // Duplicate placeholder definition spam (common when reusing ids in SPA/Ajaxify).
+          if (s0.includes('[EzoicAds JS]: Placeholder Id') && s0.includes('has already been defined')) return true;
+          // Ezoic debugger iframe spam.
+          if (s0.includes('Debugger iframe already exists')) return true;
+          // Missing placeholder spam (we already guard showAds; Ezoic still logs sometimes).
+          if (s0.includes('HTML element with id ezoic-pub-ad-placeholder-') && s0.includes('does not exist')) return true;
+          return false;
+        } catch (e) {
+          return false;
+        }
+      };
+
+      const wrap = (method) => {
+        const orig = console[method];
+        if (typeof orig !== 'function') return;
+        console[method] = function (...args) {
+          if (shouldMute(args)) return;
+          return orig.apply(console, args);
+        };
+      };
+
+      wrap('log');
+      wrap('info');
+      wrap('warn');
+      wrap('error');
+    } catch (e) {}
+  }
+
+  // Some CMP/TCF stubs rely on a hidden iframe named `__tcfapiLocator` to route postMessage calls.
+  // In SPA/Ajaxify navigations, that iframe can be removed/replaced unexpectedly, causing noisy
+  // "postMessage" / "addtlConsent" null errors. Ensuring it's present makes the environment stable.
+  function ensureTcfApiLocator() {
+    try {
+      // If a CMP is not present, do nothing.
+      if (typeof window.__tcfapi !== 'function' && typeof window.__cmp !== 'function') return;
+      if (document.getElementById('__tcfapiLocator')) return;
+      const f = document.createElement('iframe');
+      f.style.display = 'none';
+      f.id = '__tcfapiLocator';
+      f.name = '__tcfapiLocator';
+      (document.body || document.documentElement).appendChild(f);
+    } catch (e) {}
+  }
+
+  
+
+function isFilledNode(node) {
+  return !!(node && node.querySelector && node.querySelector('iframe, ins, img, video, [data-google-container-id]'));
+}
+
+// Ezoic injects inline `min-height:400px !important` on one or more nested wrappers.
+// If the creative is 250px, this leaves ~150px empty space. Because it's inline+important,
+// CSS alone cannot fix it reliably — we must rewrite the inline style.
+function tightenEzoicMinHeight(wrap) {
+  try {
+    if (!wrap || !wrap.querySelector) return;
+
+    const iframes = wrap.querySelectorAll('iframe');
+    if (!iframes || !iframes.length) return;
+
+    // Find the closest "big" ezoic container that carries the 400px min-height.
+    const firstIframe = iframes[0];
+    let refNode = null;
+    let p = firstIframe && firstIframe.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') || st.includes('min-height:400px')) {
+          refNode = p;
+          break;
+        }
+      }
+      p = p.parentElement;
+    }
+    if (!refNode) {
+      refNode = wrap.querySelector('.ezoic-ad-adaptive') || wrap.querySelector('.ezoic-ad') || wrap;
+    }
+
+    let refTop = 0;
+    try { refTop = refNode.getBoundingClientRect().top; } catch (e) { refTop = 0; }
+
+    // Compute the rendered height needed inside refNode (visible iframes only).
+    let maxBottom = 0;
+    iframes.forEach((f) => {
+      if (!f || !f.getBoundingClientRect) return;
+      const rect = f.getBoundingClientRect();
+      if (rect.width <= 1 || rect.height <= 1) return;
+      const bottom = rect.bottom - refTop;
+      maxBottom = Math.max(maxBottom, bottom);
+    });
+
+    // Fallback to attr/offset if layout metrics are not available.
+    if (!maxBottom) {
+      iframes.forEach((f) => {
+        const ah = parseInt(f.getAttribute('height') || '0', 10);
+        const oh = f.offsetHeight || 0;
+        maxBottom = Math.max(maxBottom, ah, oh);
+      });
+    }
+    if (!maxBottom) return;
+
+    // NOTE: Do NOT add the Ezoic badge (reportline) height here.
+    // It is absolutely positioned and should not reserve layout space.
+
+    const h = Math.max(1, Math.ceil(maxBottom));
+
+    const tightenNode = (node) => {
+      if (!node || !node.style) return;
+      try { node.style.setProperty('min-height', h + 'px', 'important'); } catch (e) { node.style.minHeight = h + 'px'; }
+      try { node.style.setProperty('height', 'auto', 'important'); } catch (e) {}
+      try { node.style.setProperty('line-height', '0', 'important'); } catch (e) {}
+    };
+
+    // Tighten refNode and any ancestor ezoic-ad nodes with the problematic min-height.
+    let cur = refNode;
+    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') || st.includes('min-height:400px')) {
+          tightenNode(cur);
+        }
+      }
+      cur = cur.parentElement;
+    }
+    tightenNode(refNode);
+
+    // Tighten any nested wrappers that also have the 400px min-height inline.
+    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') || st.includes('min-height:400px')) {
+        tightenNode(n);
+      }
+    });
+
+    // Mobile friendliness: avoid giant fixed widths causing overflow/reflow.
+    if (isMobile()) {
+      [refNode].forEach((n) => {
+        try { n.style.setProperty('width', '100%', 'important'); } catch (e) {}
+        try { n.style.setProperty('max-width', '100%', 'important'); } catch (e) {}
+        try { n.style.setProperty('min-width', '0', 'important'); } catch (e) {}
+      });
+    }
+  } catch (e) {}
+}
+
+function watchWrapForFill(wrap) {
+  try {
+    if (!wrap || wrap.__ezFillObs) return;
+
+    // Ezoic can (re)apply inline styles after fill; keep tightening for a short window.
+    const start = now();
+    const tightenBurst = () => {
+      try { tightenEzoicMinHeight(wrap); } catch (e) {}
+      if (now() - start < 6000) {
+        setTimeout(tightenBurst, 350);
+      }
+    };
+
+    const obs = new MutationObserver((muts) => {
+      // If anything that looks like ad content appears, treat as filled.
+      if (isFilledNode(wrap)) {
+        wrap.classList.remove('is-empty');
+        tightenBurst();
+      }
+
+      // If Ezoic changes inline style on descendants (min-height:400!important), tighten again.
+      for (const m of muts) {
+        if (m.type === 'attributes' && m.attributeName === 'style') {
+          try { tightenEzoicMinHeight(wrap); } catch (e) {}
+          break;
+        }
+      }
+
+      // Disconnect only after the burst window to avoid missing late style rewrites.
+      if (now() - start > 7000) {
+        try { obs.disconnect(); } catch (e) {}
+        wrap.__ezFillObs = null;
+      }
+    });
+
+    obs.observe(wrap, { childList: true, subtree: true, attributes: true, attributeFilter: ['style'] });
+    wrap.__ezFillObs = obs;
+  } catch (e) {}
+}
+
+// Global safety net: sometimes Ezoic swaps nodes in ways that bypass our per-wrap observers.
+// When we see an Ezoic container with min-height:400!important inside posts/topics, shrink it.
+function globalGapFixInit() {
+  try {
+    if (window.__nodebbEzoicGapFix) return;
+    window.__nodebbEzoicGapFix = true;
+
+    // Observe only the main content area to minimize overhead.
+    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 = (root) => {
+      if (!root || !root.querySelectorAll) return;
+      const nodes = root.querySelectorAll('.ezoic-ad[style*="min-height"], .ezoic-ad-adaptive[style*="min-height"]');
+      nodes.forEach((n) => {
+        const st = (n.getAttribute('style') || '').toLowerCase();
+        if (!st.includes('min-height:400')) return;
+        if (!inPostArea(n)) return;
+        try {
+          const tmpWrap = n.closest('.' + WRAP_CLASS) || n.parentElement;
+          tightenEzoicMinHeight(tmpWrap || n);
+        } catch (e) {}
+      });
+    };
+
+    requestAnimationFrame(() => maybeFix(root));
+
+    // Batch DOM mutation processing into a single rAF to avoid doing work per mutation.
+    const pending = new Set();
+    let scheduled = false;
+    const scheduleFlush = () => {
+      if (scheduled) return;
+      scheduled = true;
+      requestAnimationFrame(() => {
+        scheduled = false;
+        pending.forEach((n) => {
+          try { maybeFix(n); } catch (e) {}
+        });
+        pending.clear();
+      });
+    };
+
+    const obs = 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.length) {
+          m.addedNodes.forEach((n) => {
+            if (n && n.nodeType === 1) pending.add(n);
+          });
+        }
+      }
+      if (pending.size) scheduleFlush();
+    });
+    obs.observe(root, { subtree: true, childList: true, attributes: true, attributeFilter: ['style'] });
+  } catch (e) {}
+}
+
+// ---------------- state ----------------
+
+  const state = {
+    pageKey: null,
+    cfg: null,
+
+    // pools (full lists) + cursors
+    allTopics: [],
+    allPosts: [],
+    allCategories: [],
+    curTopics: 0,
+    curPosts: 0,
+    curCategories: 0,
+
+    // per-id throttle
+    lastShowById: new Map(),
 
-  // 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;
+    // observers / schedulers
+    domObs: null,
+    io: null,
+    ioMargin: null,
 
-  const MAX_INFLIGHT = { desktop: 4, mobile: 3 };
+    // internal mutations guard
+    internalDomChange: 0,
 
-  const SEL = {
-    topic:    'li[component="category/topic"]',
-    post:     '[component="post"][data-pid]',
-    category: 'li[component="categories/category"]',
+    // preloading budget
+    inflight: 0,
+    pending: [],
+    pendingSet: new Set(),
+
+    // scroll boost
+    scrollBoostUntil: 0,
+    lastScrollY: 0,
+    lastScrollTs: 0,
+
+    // hero
+    heroDoneForPage: false,
+
+    // run scheduler
+    runQueued: false,
+    burstActive: false,
+    burstDeadline: 0,
+    burstCount: 0,
+    lastBurstReqTs: 0,
   };
 
-  // ─── Utils ───────────────────────────────────────────────────────────────────
+  // Soft block during navigation / heavy DOM churn
+  let blockedUntil = 0;
+  const insertingIds = new Set();
 
-  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
+  function now() { return Date.now(); }
+  function isBlocked() { return now() < blockedUntil; }
 
-  function now()      { return Date.now(); }
-  function isMobile() { try { return window.innerWidth < 768; } catch (e) { return false; } }
-  function isBoosted(){ return now() < (st.boostUntil || 0); }
-  function isBlocked(){ return now() < blockedUntil; }
+  // ---------------- utils ----------------
 
-  function normBool(v) {
+  function normalizeBool(v) {
     return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
-  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)) {
+  function uniqInts(lines) {
+    const out = [];
+    const seen = new Set();
+    for (const v of lines) {
       const n = parseInt(v, 10);
-      if (Number.isFinite(n) && n > 0 && !seen.has(n)) { seen.add(n); out.push(n); }
+      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]'));
-  }
-
-  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 parsePool(raw) {
+    if (!raw) return [];
+    const lines = String(raw)
+      .split(/\r?\n/)
+      .map(s => s.trim())
+      .filter(Boolean);
+    return uniqInts(lines);
   }
 
   function getPageKey() {
     try {
-      const d = window.ajaxify && window.ajaxify.data;
-      if (d) {
-        if (d.tid) return 'topic:'    + d.tid;
-        if (d.cid) return 'category:' + d.cid;
+      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;
   }
 
-  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 isMobile() {
+    try { return window.innerWidth < 768; } catch (e) { return false; }
   }
 
-  function withInternal(fn) {
-    st.internalMut++;
-    try { fn(); } finally { st.internalMut--; }
+  function isBoosted() {
+    return now() < (state.scrollBoostUntil || 0);
   }
 
-  // ─── State ───────────────────────────────────────────────────────────────────
+  function getPreloadRootMargin() {
+    if (isMobile()) return isBoosted() ? PRELOAD_MARGIN_MOBILE_BOOST : PRELOAD_MARGIN_MOBILE;
+    return isBoosted() ? PRELOAD_MARGIN_DESKTOP_BOOST : PRELOAD_MARGIN_DESKTOP;
+  }
 
-  const st = {
-    pageKey: null,
-    cfg: null,
+  function getMaxInflight() {
+    const base = isMobile() ? MAX_INFLIGHT_MOBILE : MAX_INFLIGHT_DESKTOP;
+    return base + (isBoosted() ? 1 : 0);
+  }
 
-    pools:   { topic: [], post: [], category: [] },
-    cursors: { topic: 0,  post: 0,  category: 0  },
+  function withInternalDomChange(fn) {
+    state.internalDomChange++;
+    try { fn(); } finally { state.internalDomChange--; }
+  }
 
-    lastShow:   new Map(),   // id → timestamp
-    inflight:   0,
-    pending:    [],
-    pendingSet: new Set(),
+  // ---------------- DOM helpers ----------------
 
-    io:         null,
-    ioMargin:   null,
-    domObs:     null,
+  function getTopicItems() {
+    return Array.from(document.querySelectorAll(SELECTORS.topicItem));
+  }
 
-    internalMut:  0,
-    boostUntil:   0,
-    lastScrollY:  0,
-    lastScrollTs: 0,
+  function getCategoryItems() {
+    return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
+  }
 
-    heroDone:     false,
-    runQueued:    false,
-    burstActive:  false,
-    burstDeadline:0,
-    burstCount:   0,
-    lastBurstTs:  0,
+  function getPostContainers() {
+    const nodes = Array.from(document.querySelectorAll(SELECTORS.postItem));
+    return nodes.filter((el) => {
+      if (!el || !el.isConnected) return false;
+      if (!el.querySelector('[component="post/content"]')) return false;
+      const parentPost = el.parentElement && el.parentElement.closest('[component="post"][data-pid]');
+      if (parentPost && parentPost !== el) return false;
+      if (el.getAttribute('component') === 'post/parent') return false;
+      return true;
+    });
+  }
 
-    // Detached wraps cache (to survive NodeBB virtual/infinite scroll recycling)
-    // kindClass -> Map(afterPos -> wrapNode)
-    detached: new Map(),
-  };
+  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';
 
-  let blockedUntil = 0;
-  const inserting  = new Set();
+    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}"]`);
+  }
 
-  // ─── Console mute (Ezoic SPA spam) ───────────────────────────────────────────
+  // ---------------- placeholder pool ----------------
 
-  function muteConsole() {
+  function getPoolEl() {
+    let el = document.getElementById(POOL_ID);
+    if (el) return el;
+    el = document.createElement('div');
+    el.id = POOL_ID;
+    el.style.cssText = 'position:fixed;left:-99999px;top:-99999px;width:1px;height:1px;overflow:hidden;opacity:0;pointer-events:none;';
+    (document.body || document.documentElement).appendChild(el);
+    return el;
+  }
+
+  function primePlaceholderPool(allIds) {
     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'));
-      };
-      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); };
+      if (!Array.isArray(allIds) || !allIds.length) return;
+      const pool = getPoolEl();
+      for (const id of allIds) {
+        if (!id) continue;
+        const domId = `${PLACEHOLDER_PREFIX}${id}`;
+        if (document.getElementById(domId)) continue;
+        const ph = document.createElement('div');
+        ph.id = domId;
+        ph.setAttribute('data-ezoic-id', String(id));
+        pool.appendChild(ph);
       }
     } catch (e) {}
   }
 
-  // ─── 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);
-    }
+  function isInPool(ph) {
+    try { return !!(ph && ph.closest && ph.closest('#' + POOL_ID)); } catch (e) { return false; }
+  }
+
+  function releaseWrapNode(wrap) {
+    try {
+      const ph = wrap && wrap.querySelector && wrap.querySelector(`[id^="${PLACEHOLDER_PREFIX}"]`);
+      if (ph) {
+        try { getPoolEl().appendChild(ph); } catch (e) {}
+        try { state.io && state.io.unobserve(ph); } catch (e) {}
+      }
+    } catch (e) {}
+    try { wrap && wrap.remove && wrap.remove(); } catch (e) {}
   }
 
-  // ─── Ezoic bridge ────────────────────────────────────────────────────────────
-  // Patch showAds so it silently skips IDs whose placeholder is not in the DOM.
+  // ---------------- network warmup ----------------
+
+  const _warmLinksDone = new Set();
+  function warmUpNetwork() {
+    try {
+      const head = document.head || document.getElementsByTagName('head')[0];
+      if (!head) return;
+      const links = [
+        // Ezoic
+        ['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],
+        // Google ads
+        ['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],
+      ];
+      for (const [rel, href, cors] of links) {
+        const key = `${rel}|${href}`;
+        if (_warmLinksDone.has(key)) continue;
+        _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 to silently skip ids not in DOM. This prevents console spam.
   function patchShowAds() {
-    const patch = () => {
+    const applyPatch = () => {
       try {
-        const ez = window.ezstandalone = window.ezstandalone || {};
-        if (window.__nbbEzoicPatched || typeof ez.showAds !== 'function') return;
-        window.__nbbEzoicPatched = true;
+        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 = Array.isArray(args[0]) ? args[0] : args;
+
+          let ids = [];
+          if (args.length === 1 && Array.isArray(args[0])) ids = args[0];
+          else ids = 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);
+            const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
             if (!ph || !ph.isConnected) continue;
             seen.add(id);
             try { orig.call(ez, id); } catch (e) {}
@@ -197,817 +596,873 @@
         };
       } catch (e) {}
     };
-    patch();
-    if (!window.__nbbEzoicPatched) {
+
+    applyPatch();
+    if (!window.__nodebbEzoicPatched) {
       try {
-        (window.ezstandalone = window.ezstandalone || {}).cmd =
-          window.ezstandalone.cmd || [];
-        window.ezstandalone.cmd.push(patch);
+        window.ezstandalone = window.ezstandalone || {};
+        window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+        window.ezstandalone.cmd.push(applyPatch);
       } catch (e) {}
     }
   }
 
-  // ─── Config ──────────────────────────────────────────────────────────────────
+  // ---------------- config ----------------
 
-  async function fetchConfig() {
-    if (st.cfg) return st.cfg;
+  async function fetchConfigOnce() {
+    if (state.cfg) return state.cfg;
     try {
-      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;
+      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 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);
+    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);
+
+    // IMPORTANT:
+    // We do NOT prime a DOM pool anymore.
+    // Keeping placeholders connected (even offscreen) can lead Ezoic/GPT to
+    // pre-define slots, which then causes "Placeholder Id X has already been defined".
+    // Instead, we create the placeholder element only when we actually inject its wrapper.
   }
 
-  // ─── Ezoic min-height tightener ──────────────────────────────────────────────
-  // Ezoic injects `min-height:400px !important` via inline style; we override it.
+  // ---------------- insertion primitives ----------------
 
-  function tightenMinHeight(wrap) {
-    try {
-      if (!wrap) return;
-      const iframes = wrap.querySelectorAll('iframe');
-
-      // If no iframe yet (or no-fill), Ezoic can still reserve a large gap via
-      // inline `min-height:400px !important` on `.ezoic-ad` elements.
-      // Inline !important beats our CSS, so we proactively shrink it.
-      if (!iframes.length) {
-        const bad = wrap.querySelectorAll('.ezoic-ad[style*="min-height"], .ezoic-ad-adaptive[style*="min-height"], span.ezoic-ad[style*="min-height"]');
-        bad.forEach(n => {
-          const s = (n.getAttribute('style') || '').toLowerCase();
-          if (s.includes('min-height:400') || s.includes('min-height: 400')) {
-            try { n.style.setProperty('min-height', '1px', 'important'); } catch (e) { n.style.minHeight = '1px'; }
-            try { n.style.setProperty('height', 'auto', 'important'); } catch (e) {}
-            try { n.style.setProperty('line-height', '0', 'important'); } catch (e) {}
-          }
-        });
-        return;
-      }
+  function buildWrap(id, kindClass, afterPos, createPlaceholder) {
+    const wrap = document.createElement('div');
+    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()));
+    // "Pinned" placements (after the first item) should remain stable.
+    if (afterPos === 1) {
+      wrap.setAttribute('data-ezoic-pin', '1');
+    }
+    wrap.style.width = '100%';
 
-      // 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')) { ref = p; break; }
-        }
-        p = p.parentElement;
-      }
-      ref = ref || wrap.querySelector('.ezoic-ad-adaptive, .ezoic-ad') || wrap;
+    if (createPlaceholder) {
+      const ph = document.createElement('div');
+      ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+      ph.setAttribute('data-ezoic-id', String(id));
+      wrap.appendChild(ph);
+    }
 
-      let refTop = 0;
-      try { refTop = ref.getBoundingClientRect().top; } catch (e) {}
+    return wrap;
+  }
 
-      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 (!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(maxH)) + 'px';
-      const set = (n) => {
-        if (!n || !n.style) return;
-        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) {}
-      };
+  function insertAfter(target, id, kindClass, afterPos) {
+    if (!target || !target.insertAdjacentElement) return null;
+    if (findWrap(kindClass, afterPos)) return null;
+    if (insertingIds.has(id)) return null;
 
-      let cur = ref;
-      while (cur && cur !== wrap) {
-        if (cur.classList && cur.classList.contains('ezoic-ad')) {
-          const s = (cur.getAttribute('style') || '').toLowerCase();
-          if (s.includes('min-height:400') || s.includes('min-height: 400')) set(cur);
-        }
-        cur = cur.parentElement;
-      }
-      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);
-      });
+    const existingPh = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
 
-      if (isMobile()) {
-        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) {}
+    insertingIds.add(id);
+    try {
+      const wrap = buildWrap(id, kindClass, afterPos, !existingPh);
+      target.insertAdjacentElement('afterend', wrap);
+
+      // If placeholder exists elsewhere (including pool), move it into the wrapper.
+      if (existingPh) {
+        try {
+          existingPh.setAttribute('data-ezoic-id', String(id));
+          if (!wrap.firstElementChild) wrap.appendChild(existingPh);
+          else wrap.replaceChild(existingPh, wrap.firstElementChild);
+        } catch (e) {}
       }
-    } catch (e) {}
-  }
 
-  function watchFill(wrap) {
-    try {
-      if (!wrap || wrap.__ezFillObs) return;
-      const start = now();
-      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'); 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) {}
+      return wrap;
+    } finally {
+      insertingIds.delete(id);
+    }
   }
 
-  // Global safety net: catch Ezoic 400px min-height inside posts.
-  function globalGapFix() {
-    try {
-      if (window.__nbbEzoicGapFix) return;
-      window.__nbbEzoicGapFix = true;
-      const root = document.getElementById('content') ||
-        document.querySelector('[component="content"], #panel') || document.body;
-      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 => {
-            if (!(n.getAttribute('style') || '').toLowerCase().includes('min-height:400')) return;
-            if (!inPost(n)) return;
-            tightenMinHeight(n.closest('.' + WRAP_CLASS) || n.parentElement || n);
-          });
-      };
-      requestAnimationFrame(() => fix(root));
-      const pending = new Set();
-      let sched = false;
-      new MutationObserver(muts => {
-        for (const m of muts) {
-          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(); });
-        }
-      }).observe(root, { subtree: true, childList: true, attributes: true, attributeFilter: ['style'] });
-    } catch (e) {}
-  }
+  function pickIdFromAll(allIds, cursorKey) {
+    const n = allIds.length;
+    if (!n) return null;
 
-  // ─── DOM helpers ─────────────────────────────────────────────────────────────
+    for (let tries = 0; tries < n; tries++) {
+      const idx = state[cursorKey] % n;
+      state[cursorKey] = (state[cursorKey] + 1) % n;
+      const id = allIds[idx];
 
-  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(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 [];
-  }
+      const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+      if (ph && ph.isConnected && !isInPool(ph)) continue;
 
-  function isAdjacentWrap(el) {
-    const n = el.nextElementSibling,  p = el.previousElementSibling;
-    return (n && n.classList.contains(WRAP_CLASS)) || (p && p.classList.contains(WRAP_CLASS));
-  }
+      return id;
+    }
 
-  function findWrapAt(kindClass, afterPos) {
-    return document.querySelector('.' + WRAP_CLASS + '.' + kindClass +
-      '[data-ezoic-after="' + afterPos + '"]');
+    return null;
   }
 
-  // ─── Wrap creation / destruction ─────────────────────────────────────────────
+  function pruneOrphanWraps(kindClass, items) {
+    // Topic pages can be virtualized (posts removed from DOM as you scroll).
+    // When that happens, previously-inserted ad wraps may become "orphan" nodes with no
+    // nearby post containers, which leads to ads clustering together when scrolling back up.
+    // We prune only *true* orphans that are far offscreen to keep the UI stable.
+    if (!items || !items.length) return 0;
+    const itemSet = new Set(items);
+    const wraps = document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`);
+    let removed = 0;
+
+    const isFilled = (wrap) => {
+      return !!(wrap.querySelector('iframe, ins, img, video, [data-google-container-id]'));
+    };
 
-  function buildWrap(id, kindClass, afterPos) {
-    const wrap = document.createElement('div');
-    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%';
-    const ph = document.createElement('div');
-    ph.id = PLACEHOLDER_PREFIX + id;
-    ph.setAttribute('data-ezoic-id', String(id));
-    wrap.appendChild(ph);
-    return wrap;
-  }
+    const hasNearbyItem = (wrap) => {
+      // NodeBB/skins can inject separators/spacers; be tolerant.
+      let prev = wrap.previousElementSibling;
+      for (let i = 0; i < 14 && prev; i++) {
+        if (itemSet.has(prev)) return true;
+        prev = prev.previousElementSibling;
+      }
+      let next = wrap.nextElementSibling;
+      for (let i = 0; i < 14 && next; i++) {
+        if (itemSet.has(next)) return true;
+        next = next.nextElementSibling;
+      }
+      return false;
+    };
 
-  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.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
-      if (ph) try { st.io && st.io.unobserve(ph); } catch (e) {}
-    } catch (e) {}
-    try { wrap.remove(); } catch (e) {}
+    wraps.forEach((wrap) => {
+      // Never prune pinned placements.
+      try {
+        if (wrap.getAttribute('data-ezoic-pin') === '1') return;
+      } catch (e) {}
+
+      // For message/topic pages we may prune filled or empty orphans if they are far away,
+      // otherwise consecutive "stacks" can appear when posts are virtualized.
+      const isMessage = (kindClass === 'ezoic-ad-message');
+      if (!isMessage && isFilled(wrap)) return; // never prune filled ads for non-message lists
+
+      // Never prune a fresh wrap: it may fill late.
+      try {
+        const created = parseInt(wrap.getAttribute('data-created') || '0', 10);
+        if (created && (now() - created) < keepEmptyWrapMs()) return;
+      } catch (e) {}
+
+if (hasNearbyItem(wrap)) {
+  try { wrap.classList && wrap.classList.remove('ez-orphan-hidden'); wrap.style && (wrap.style.display = ''); } catch (e) {}
+  return;
+}
+
+// If the anchor item is no longer in the DOM (virtualized), hide the wrap so ads never "stack"
+// back-to-back while scrolling. We'll recycle it when its anchor comes back.
+try { wrap.classList && wrap.classList.add('ez-orphan-hidden'); wrap.style && (wrap.style.display = 'none'); } catch (e) {}
+
+// For message ads: only release if far offscreen to avoid perceived "vanishing" during fast scroll.
+if (isMessage) {
+  try {
+    const r = wrap.getBoundingClientRect();
+    const vh = Math.max(1, window.innerHeight || 1);
+    const farAbove = r.bottom < -vh * 2;
+    const farBelow = r.top > vh * 4;
+    if (!farAbove && !farBelow) return;
+  } catch (e) {
+    return;
   }
+}
+
+withInternalDomChange(() => releaseWrapNode(wrap));
+removed++;
+    });
 
-  function getDetachedMap(kindClass) {
-    let m = st.detached.get(kindClass);
-    if (!m) { m = new Map(); st.detached.set(kindClass, m); }
-    return m;
+    return removed;
   }
 
-  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);
+  function decluster(kindClass) {
+    // Remove "near-consecutive" wraps (keep the first). Be tolerant of spacer nodes.
+    const wraps = Array.from(document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`));
+    if (wraps.length < 2) return 0;
+
+    const isWrap = (el) => !!(el && el.classList && el.classList.contains(WRAP_CLASS));
+
+    const isFilled = (wrap) => {
+      return !!(wrap && wrap.querySelector && wrap.querySelector('iframe, ins, img, video, [data-google-container-id]'));
+    };
+
+    const isFresh = (wrap) => {
+      try {
+        const created = parseInt(wrap.getAttribute('data-created') || '0', 10);
+        return created && (now() - created) < keepEmptyWrapMs();
+      } catch (e) {
+        return false;
+      }
+    };
 
-      // Unobserve placeholder while detached
+    let removed = 0;
+    for (const w of wraps) {
+      // Never decluster pinned placements.
       try {
-        const ph = wrap.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
-        if (ph) try { st.io && st.io.unobserve(ph); } catch (e) {}
+        if (w.getAttribute && w.getAttribute('data-ezoic-pin') === '1') continue;
       } catch (e) {}
 
-      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) {}
-      }
-      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) {}
-        });
-      }
+      let prev = w.previousElementSibling;
+      for (let i = 0; i < 3 && prev; i++) {
+        if (isWrap(prev)) {
+          // If the previous wrap is pinned, keep this one (spacing is intentional).
+          try {
+            if (prev.getAttribute && prev.getAttribute('data-ezoic-pin') === '1') break;
+          } catch (e) {}
 
-      // Actually detach from DOM
-      try { wrap.remove(); } catch (e) {}
-    } catch (e) {
-      try { dropWrap(wrap); } catch (x) {}
-    }
-  }
+          // Never remove a wrap that is already filled; otherwise it looks like
+          // ads "disappear" while scrolling. Only remove the empty neighbour.
+          const prevFilled = isFilled(prev);
+          const curFilled = isFilled(w);
 
-  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;
+          if (curFilled) {
+            // If the previous one is empty (and not fresh), drop the previous instead.
+            if (!prevFilled && !isFresh(prev)) {
+              withInternalDomChange(() => releaseWrapNode(prev));
+              removed++;
+            }
+            break;
+          }
+
+          // Current is empty.
+          // Don't decluster two "fresh" empty wraps — it can reduce fill on slow auctions.
+          // Only decluster when previous is filled, or when current is stale.
+          if (prevFilled || !isFresh(w)) {
+            withInternalDomChange(() => releaseWrapNode(w));
+            removed++;
+          }
+          break;
+        }
+        prev = prev.previousElementSibling;
+      }
     }
-    return null; // all IDs currently mounted
+    return removed;
   }
 
-  // ─── IntersectionObserver ────────────────────────────────────────────────────
+  // ---------------- show (preload / fast fill) ----------------
+
+  function ensurePreloadObserver() {
+    const desiredMargin = getPreloadRootMargin();
+    if (state.io && state.ioMargin === desiredMargin) return state.io;
+
+    if (state.io) {
+      try { state.io.disconnect(); } catch (e) {}
+      state.io = null;
+    }
 
-  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 {
-      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);
+      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 idAttr = el && el.getAttribute && el.getAttribute('data-ezoic-id');
+          const id = parseInt(idAttr, 10);
+          if (Number.isFinite(id) && id > 0) enqueueShow(id);
         }
-      }, { rootMargin: margin, threshold: 0 });
-      st.ioMargin = margin;
-      // Re-observe all live placeholders.
-      document.querySelectorAll('[id^="' + PLACEHOLDER_PREFIX + '"]')
-        .forEach(ph => { try { st.io.observe(ph); } catch (e) {} });
-    } catch (e) { st.io = st.ioMargin = null; }
-    return st.io;
+      }, { root: null, rootMargin: desiredMargin, threshold: 0 });
+
+      state.ioMargin = desiredMargin;
+    } catch (e) {
+      state.io = null;
+      state.ioMargin = null;
+    }
+
+    // Re-observe current placeholders
+    try {
+      if (state.io) {
+        const nodes = document.querySelectorAll(`[id^="${PLACEHOLDER_PREFIX}"]`);
+        nodes.forEach((n) => { try { state.io.observe(n); } catch (e) {} });
+      }
+    } catch (e) {}
+
+    return state.io;
   }
 
-  function observePh(id) {
-    const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
+  function observePlaceholder(id) {
+    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
     if (!ph || !ph.isConnected) return;
     ph.setAttribute('data-ezoic-id', String(id));
-    try { ensureIO() && ensureIO().observe(ph); } catch (e) {}
-    // Immediate fire if already near viewport.
+
+    const io = ensurePreloadObserver();
+    try { io && io.observe(ph); } catch (e) {}
+
+    // If already near viewport, fire immediately.
+    // Mobile tends to scroll faster + has slower auctions, so we fire earlier.
     try {
       const r = ph.getBoundingClientRect();
-      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);
+      const mobile = isMobile();
+      const screens = isBoosted()
+        ? (mobile ? 9.0 : 5.0)
+        : (mobile ? 6.0 : 3.0);
+      const minBottom = isBoosted()
+        ? (mobile ? -2600 : -1500)
+        : (mobile ? -1400 : -800);
+      if (r.top < window.innerHeight * screens && r.bottom > minBottom) enqueueShow(id);
     } catch (e) {}
   }
 
-  // ─── Show queue ──────────────────────────────────────────────────────────────
-
   function enqueueShow(id) {
     if (!id || isBlocked()) return;
-    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); }
+
+    // per-id throttle
+    const t = now();
+    const last = state.lastShowById.get(id) || 0;
+    if (t - last < 900) return;
+
+    const max = getMaxInflight();
+    if (state.inflight >= max) {
+      if (!state.pendingSet.has(id)) {
+        state.pending.push(id);
+        state.pendingSet.add(id);
+      }
       return;
     }
+
     startShow(id);
   }
 
   function drainQueue() {
     if (isBlocked()) return;
-    while (st.inflight < getMaxInflight() && st.pending.length) {
-      const id = st.pending.shift();
-      st.pendingSet.delete(id);
+    const max = getMaxInflight();
+    while (state.inflight < max && state.pending.length) {
+      const id = state.pending.shift();
+      state.pendingSet.delete(id);
       startShow(id);
     }
   }
 
-  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');
-          // Kill any large reserved gap even when there is no iframe.
-          tightenMinHeight(w);
-          watchFill(w);
-          scheduleHardPruneEmpty(id);
-        }
-      } catch (e) {}
-    }, 15_000);
-  }
+  function markEmptyWrapper(id) {
+    // If still empty after delay, mark empty for CSS (1px)
+    try {
+      const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+      if (!ph || !ph.isConnected) return;
+      const wrap = ph.closest ? ph.closest(`.${WRAP_CLASS}`) : null;
+      if (!wrap) return;
 
-  // If a placement stays empty for a long time, remove it entirely so the user
-  // doesn't get persistent blank blocks. This also frees the placeholder ID so
-  // a future injection can try a different one.
-  function scheduleHardPruneEmpty(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 still not filled after 45s, drop it.
-        if (!isFilled(w)) {
-          // Also ensure it isn't cached as detached.
+      setTimeout(() => {
+        try {
+          const ph2 = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+          if (!ph2 || !ph2.isConnected) return;
+          const w2 = ph2.closest ? ph2.closest(`.${WRAP_CLASS}`) : null;
+          if (!w2) return;
+
+          // Don't collapse "fresh" placements; slow auctions/CMP can fill late.
           try {
-            const kind = Array.from(w.classList).find(c => c.startsWith('ezoic-ad-'));
-            if (kind) {
-              const afterPos = parseInt(w.getAttribute('data-ezoic-after') || '0', 10);
-              const m = st.detached.get(kind);
-              if (m && afterPos && m.get(afterPos) === w) m.delete(afterPos);
-            }
+            const created = parseInt(w2.getAttribute('data-created') || '0', 10);
+            if (created && (now() - created) < keepEmptyWrapMs()) return;
           } catch (e) {}
-          withInternal(() => dropWrap(w));
-        }
-      } catch (e) {}
-    }, 45_000);
+
+          const hasAd = !!(ph2.querySelector && ph2.querySelector('iframe, ins, img, .ez-ad, .ezoic-ad'));
+          if (!hasAd) {
+            w2.classList.add('is-empty');
+            watchWrapForFill(w2);
+          } else {
+            w2.classList.remove('is-empty');
+            tightenEzoicMinHeight(w2);
+          }
+        } catch (e) {}
+      }, 15000);
+    } catch (e) {}
   }
 
   function startShow(id) {
     if (!id || isBlocked()) return;
-    st.inflight++;
-    let done = false;
-    const finish = () => {
-      if (done) return; done = true;
-      st.inflight = Math.max(0, st.inflight - 1);
+
+    state.inflight++;
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      state.inflight = Math.max(0, state.inflight - 1);
       drainQueue();
     };
-    const timeout = setTimeout(finish, 6500);
+
+    const hardTimer = setTimeout(release, 6500);
 
     requestAnimationFrame(() => {
       try {
         if (isBlocked()) return;
-        const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
+
+        const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
         if (!ph || !ph.isConnected) return;
-        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 || {};
+        // If the placeholder already has creative, avoid re-showing.
+        // Re-showing is a common source of "Placeholder Id X has already been defined".
+        try {
+          if (ph.querySelector && ph.querySelector('iframe, ins, img, video, [data-google-container-id]')) {
+            clearTimeout(hardTimer);
+            release();
+            return;
+          }
+        } catch (e) {}
+
+        const t = now();
+        const last = state.lastShowById.get(id) || 0;
+        if (t - last < 900) return;
+        state.lastShowById.set(id, t);
+
+        window.ezstandalone = window.ezstandalone || {};
+        const ez = window.ezstandalone;
+
         const doShow = () => {
           try { ez.showAds(id); } catch (e) {}
-          scheduleMarkEmpty(id);
+          try { markEmptyWrapper(id); } catch (e) {}
           try {
-            const w = document.getElementById(PLACEHOLDER_PREFIX + id)
-              ?.closest('.' + WRAP_CLASS);
-            if (w) {
-              watchFill(w);
-              setTimeout(() => tightenMinHeight(w), 900);
-              setTimeout(() => tightenMinHeight(w), 2200);
+            const phw = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+            const ww = phw && phw.closest ? phw.closest(`.${WRAP_CLASS}`) : null;
+            if (ww) {
+              watchWrapForFill(ww);
+              setTimeout(() => { try { tightenEzoicMinHeight(ww); } catch (e) {} }, 900);
+              setTimeout(() => { try { tightenEzoicMinHeight(ww); } catch (e) {} }, 2200);
             }
           } catch (e) {}
-          setTimeout(() => { clearTimeout(timeout); finish(); }, 650);
+          setTimeout(() => { clearTimeout(hardTimer); release(); }, 650);
         };
-        if (Array.isArray(ez.cmd)) try { ez.cmd.push(doShow); } catch (e) { doShow(); }
-        else doShow();
-      } finally {} // timeout covers early returns
-    });
-  }
-
-  // ─── Core injection ──────────────────────────────────────────────────────────
-
-  function getOrdinal(el, idx) {
-    try {
-      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 idx + 1;
-  }
 
-  function computeTargets(items, interval, showFirst) {
-    // Build ordinal map and determine target positions.
-    const map = new Map();
-    let max = 0;
-    items.forEach((el, i) => {
-      const ord = getOrdinal(el, i);
-      map.set(ord, el);
-      if (ord > max) max = ord;
+        if (Array.isArray(ez.cmd)) {
+          try { ez.cmd.push(doShow); } catch (e) { doShow(); }
+        } else {
+          doShow();
+        }
+      } finally {
+        // hardTimer releases on early return
+      }
     });
-    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) };
   }
 
-  /**
-   * 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; }
-      }
+  // ---------------- core injection ----------------
 
-      if (!found) {
-        // Detach instead of destroy so ads can survive DOM recycling.
-        withInternal(() => detachWrap(kindClass, wrap));
-      }
-    });
+function getItemOrdinal(el, fallbackIndex) {
+  try {
+    if (!el) return fallbackIndex + 1;
+    const di = el.getAttribute('data-index') || (el.dataset && (el.dataset.index || el.dataset.postIndex));
+    if (di !== null && di !== undefined && 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 !== undefined && d1 !== '' && !isNaN(d1)) {
+      const n = parseInt(d1, 10);
+      if (Number.isFinite(n) && n > 0) return n;
+    }
+  } catch (e) {}
+  return fallbackIndex + 1;
+}
+
+function buildOrdinalMap(items) {
+  const map = new Map();
+  let max = 0;
+  for (let i = 0; i < items.length; i++) {
+    const el = items[i];
+    const ord = getItemOrdinal(el, i);
+    map.set(ord, el);
+    if (ord > max) max = ord;
   }
+  return { map, max };
+}
 
-  function reapDetached(kindClass) {
-    // Soft-prune very old detached nodes.
-    try {
-      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 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);
+    }
+    // unique + sorted
+    return Array.from(new Set(out)).sort((a, b) => a - b);
   }
 
-  function injectWraps(kindClass, items, interval, showFirst, poolKey, cursorKey) {
+  function injectBetween(kindClass, items, interval, showFirst, allIds, cursorKey) {
     if (!items.length) return 0;
-    const { map, targets } = computeTargets(items, interval, showFirst);
-    const max = MAX_INSERTS_PER_RUN + (isBoosted() ? 1 : 0);
-    let n = 0;
 
-    const detachedMap = st.detached.get(kindClass);
+    const { map: ordinalMap, max: maxOrdinal } = buildOrdinalMap(items);
+    const targets = computeTargets(maxOrdinal, interval, showFirst);
+    let inserted = 0;
+    const maxInserts = MAX_INSERTS_PER_RUN + (isBoosted() ? 1 : 0);
 
-    for (const pos of targets) {
-      if (n >= max) break;
-      const el = map.get(pos);
+    for (const afterPos of targets) {
+      if (inserted >= maxInserts) break;
+      const el = ordinalMap.get(afterPos);
+      if (!el) continue;
       if (!el || !el.isConnected) continue;
 
-      // ── 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;
+      // Viewport guard: when the user scrolls UP, NodeBB may load items above the fold.
+      // Injecting ads there immediately causes wrap pile-ups near the top.
+      // Skip targets whose anchor is above the viewport top at injection time.
+      try {
+        if (scrollDir < 0 && el.getBoundingClientRect().bottom < 0) continue;
+      } catch (e) {}
+
+      if (isAdjacentAd(el)) continue;
+      if (findWrap(kindClass, afterPos)) continue;
+
+      let id = pickIdFromAll(allIds, cursorKey);
+      let recycledWrap = null;
+
+      // If the pool is exhausted (all placeholder ids already mounted), recycle a wrap that is far
+      // above the viewport by moving it to the new target instead of creating a new placeholder.
+      // This avoids "Placeholder Id X has already been defined" and also ensures ads keep
+      // appearing on very long infinite scroll sessions.
+      if (!id) {
+        // Safe mode: disable recycling for topic message ads to prevent visual "jumping"
+        // (ads seemingly moving back under the first post during virtualized scroll).
+        const allowRecycle = kindClass !== 'ezoic-ad-message';
+        recycledWrap = (allowRecycle && scrollDir > 0) ? pickRecyclableWrap(kindClass) : null;
+        if (recycledWrap) {
+          id = recycledWrap.getAttribute('data-ezoic-wrapid') || '';
         }
       }
 
-      const id = pickId(poolKey, cursorKey);
       if (!id) break;
 
-      const wrap = buildWrap(id, kindClass, pos);
-      withInternal(() => el.insertAdjacentElement('afterend', wrap));
-      observePh(id);
-      n++;
+      const wrap = recycledWrap
+        ? moveWrapAfter(el, recycledWrap, kindClass, afterPos)
+        : insertAfter(el, id, kindClass, afterPos);
+      if (!wrap) continue;
+
+      // observePlaceholder is safe for existing ids (it is idempotent) and helps with "late fill"
+      // after ajaxify/infinite scroll mutations.
+      observePlaceholder(id);
+      inserted++;
     }
-    return n;
-  }
 
-  // ─── 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.
+    return inserted;
+  }
 
-  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;
+  function pickRecyclableWrap(kindClass) {
+    // Only recycle wrappers that are well above the viewport to avoid visible "disappearing".
+    // With very small id pools (e.g. 6 ids), recycling is the only way to keep ads appearing
+    // on long topics without redefining placeholders.
+    const wraps = document.querySelectorAll('.' + kindClass + '[data-ezoic-wrapid]');
+    if (!wraps || !wraps.length) return null;
+
+    const vh = Math.max(300, window.innerHeight || 800);
+    // Recycle only when the wrapper is far above the viewport.
+    // This keeps ads on-screen longer (especially on mobile) and reduces "blink".
+    const threshold = -Math.min(9000, Math.round(vh * 6));
+
+    let best = null;
+    let bestBottom = Infinity;
+    for (const w of wraps) {
+      if (!w || !w.isConnected) continue;
+      if (w.getAttribute && w.getAttribute('data-ezoic-pin') === '1') continue;
+      const rect = w.getBoundingClientRect();
+      if (rect.bottom < threshold) {
+        if (rect.bottom < bestBottom) {
+          bestBottom = rect.bottom;
+          best = w;
+        }
+      }
+    }
+    return best;
+  }
 
-        // 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);
-        });
+  function moveWrapAfter(anchorEl, wrap, kindClass, afterPos) {
+    try {
+      if (!anchorEl || !wrap || !wrap.isConnected) return null;
 
-        // 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);
-        });
+      wrap.setAttribute('data-ezoic-after', String(afterPos));
+      anchorEl.insertAdjacentElement('afterend', wrap);
 
-        // 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) {}
-    });
+      // Ensure minimal layout impact.
+      try { wrap.style.contain = 'layout style paint'; } catch (e) {}
+      try { tightenStickyIn(wrap); } catch (e) {}
+      return wrap;
+    } catch (e) {
+      return null;
+    }
   }
 
-  // ─── runCore ─────────────────────────────────────────────────────────────────
-
   async function runCore() {
     if (isBlocked()) return 0;
+
     patchShowAds();
-    const cfg = await fetchConfig();
+
+    const cfg = await fetchConfigOnce();
     if (!cfg || cfg.excluded) return 0;
     initPools(cfg);
 
     const kind = getKind();
     let inserted = 0;
 
-    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');
+    if (kind === 'topic') {
+      if (normalizeBool(cfg.enableMessageAds)) {
+        const items = getPostContainers();
+        pruneOrphanWraps('ezoic-ad-message', items);
+        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') {
+      if (normalizeBool(cfg.enableBetweenAds)) {
+        const items = getTopicItems();
+        pruneOrphanWraps('ezoic-ad-between', items);
+        inserted += injectBetween(
+          'ezoic-ad-between',
+          items,
+          Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
+          normalizeBool(cfg.showFirstTopicAd),
+          state.allTopics,
+          'curTopics'
+        );
+        decluster('ezoic-ad-between');
+      }
+    } else if (kind === 'categories') {
+      if (normalizeBool(cfg.enableCategoryAds)) {
+        const items = getCategoryItems();
+        pruneOrphanWraps('ezoic-ad-categories', items);
+        inserted += injectBetween(
+          'ezoic-ad-categories',
+          items,
+          Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
+          normalizeBool(cfg.showFirstCategoryAd),
+          state.allCategories,
+          'curCategories'
+        );
+        decluster('ezoic-ad-categories');
+      }
     }
 
     return inserted;
   }
 
-  // ─── Hero ad (inject immediately after first item) ───────────────────────────
+  async function insertHeroAdEarly() {
+    if (state.heroDoneForPage || isBlocked()) return;
 
-  async function heroAd() {
-    if (st.heroDone || isBlocked()) return;
-    const cfg = await fetchConfig();
+    const cfg = await fetchConfigOnce();
     if (!cfg || cfg.excluded) return;
     initPools(cfg);
 
     const kind = getKind();
-    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; }
+    let items = [];
+    let allIds = [];
+    let cursorKey = '';
+    let kindClass = '';
+    let 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);
+    } else {
+      return;
+    }
 
-    if (!items.length || !showFirst) { st.heroDone = true; return; }
+    if (!items.length) return;
+    if (!showFirst) { state.heroDoneForPage = true; return; }
 
+    const afterPos = 1;
     const el = items[0];
-    if (!el || !el.isConnected || isAdjacentWrap(el) || findWrapAt(kindClass, 1))
-      { st.heroDone = true; return; }
+    if (!el || !el.isConnected) return;
+    if (isAdjacentAd(el)) return;
+    if (findWrap(kindClass, afterPos)) { state.heroDoneForPage = true; return; }
 
-    const id = pickId(poolKey, cursorKey);
+    const id = pickIdFromAll(allIds, cursorKey);
     if (!id) return;
 
-    const wrap = buildWrap(id, kindClass, 1);
-    withInternal(() => el.insertAdjacentElement('afterend', wrap));
-    st.heroDone = true;
-    observePh(id);
+    const wrap = insertAfter(el, id, kindClass, afterPos);
+    if (!wrap) return;
+
+    state.heroDoneForPage = true;
+    observePlaceholder(id);
+    // Hero placement is expected to be visible right away (after first item),
+    // so kick a fill request immediately instead of waiting only for IO callbacks.
     enqueueShow(id);
-    drainQueue();
+    startShowQueue();
   }
 
-  // ─── Burst scheduler ─────────────────────────────────────────────────────────
+  // ---------------- scheduler ----------------
+
+  function scheduleRun(delayMs = 0, cb) {
+    if (state.runQueued) return;
+    state.runQueued = true;
 
-  function scheduleRun(delay, cb) {
-    if (st.runQueued) return;
-    st.runQueued = true;
     const run = async () => {
-      st.runQueued = false;
-      if (getPageKey() !== st.pageKey) return;
-      let n = 0;
-      try { n = await runCore(); } catch (e) {}
-      try { cb && cb(n); } catch (e) {}
+      state.runQueued = false;
+      const pk = getPageKey();
+      if (state.pageKey && pk !== state.pageKey) return;
+      let inserted = 0;
+      try { inserted = await runCore(); } catch (e) { inserted = 0; }
+      try { cb && cb(inserted); } catch (e) {}
     };
-    const go = () => requestAnimationFrame(run);
-    delay > 0 ? setTimeout(go, delay) : go();
+
+    const doRun = () => requestAnimationFrame(run);
+    if (delayMs > 0) setTimeout(doRun, delayMs);
+    else doRun();
   }
 
-  function burst() {
+  function requestBurst() {
     if (isBlocked()) return;
+
     const t = now();
-    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;
+    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;
+
     const step = () => {
-      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);
+      if (getPageKey() !== pk) { state.burstActive = false; return; }
+      if (isBlocked()) { state.burstActive = false; return; }
+      if (now() > state.burstDeadline) { state.burstActive = false; return; }
+      if (state.burstCount >= 8) { state.burstActive = false; return; }
+
+      state.burstCount++;
+      scheduleRun(0, (inserted) => {
+        // Continue while we are still inserting or we have pending shows.
+        const hasWork = inserted > 0 || state.pending.length > 0;
+        if (!hasWork) { state.burstActive = false; return; }
+        // Short delay keeps UI smooth while catching late DOM waves.
+        setTimeout(step, inserted > 0 ? 120 : 220);
       });
     };
+
     step();
   }
 
-  // ─── Lifecycle ───────────────────────────────────────────────────────────────
+  // ---------------- lifecycle ----------------
 
   function cleanup() {
     blockedUntil = now() + 1200;
-    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();
+      document.querySelectorAll(`.${WRAP_CLASS}`).forEach((el) => releaseWrapNode(el));
     } 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.
+
+    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;
+
+    // keep observers alive
   }
 
-  function shouldReact(mutations) {
+  function shouldReactToMutations(mutations) {
+    // Fast filter: only react if relevant nodes were added/removed.
     for (const m of mutations) {
-      if (!m.addedNodes || !m.addedNodes.length) continue;
+      if (!m.addedNodes || m.addedNodes.length === 0) continue;
       for (const n of m.addedNodes) {
         if (!n || n.nodeType !== 1) continue;
-        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))))
+        const el = /** @type {Element} */ (n);
+        if (
+          el.matches?.(SELECTORS.postItem) ||
+          el.matches?.(SELECTORS.topicItem) ||
+          el.matches?.(SELECTORS.categoryItem) ||
+          el.querySelector?.(SELECTORS.postItem) ||
+          el.querySelector?.(SELECTORS.topicItem) ||
+          el.querySelector?.(SELECTORS.categoryItem)
+        ) {
           return true;
+        }
       }
     }
     return false;
   }
 
-  function ensureDomObs() {
-    if (st.domObs) return;
-    st.domObs = new MutationObserver(muts => {
-      if (st.internalMut > 0 || isBlocked()) return;
-      if (shouldReact(muts)) burst();
+  function ensureDomObserver() {
+    if (state.domObs) return;
+
+    state.domObs = new MutationObserver((mutations) => {
+      if (state.internalDomChange > 0) return;
+      if (isBlocked()) return;
+      if (!shouldReactToMutations(mutations)) return;
+      requestBurst();
     });
-    try { st.domObs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
-  }
 
-  // ─── NodeBB event bindings ───────────────────────────────────────────────────
+    try {
+      state.domObs.observe(document.body, { childList: true, subtree: true });
+    } catch (e) {}
+  }
 
   function bindNodeBB() {
     if (!$) return;
-    $(window).off('.ezoicNbb');
-    $(window).on('action:ajaxify.start.ezoicNbb',         ()  => cleanup());
-    $(window).on('action:ajaxify.end.ezoicNbb',           ()  => {
-      st.pageKey = getPageKey();
+
+    $(window).off('.ezoicInfinite');
+
+    $(window).on('action:ajaxify.start.ezoicInfinite', () => {
+      cleanup();
+    });
+
+    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
+      state.pageKey = getPageKey();
       blockedUntil = 0;
-      muteConsole(); warmNetwork(); patchShowAds();
-      globalGapFix(); ensureIO(); ensureDomObs();
-      heroAd().catch(() => {});
-      burst();
-      setTimeout(schedulePileFix, 80);
-      setTimeout(schedulePileFix, 500);
+
+      muteNoisyConsole();
+      ensureTcfApiLocator();
+      warmUpNetwork();
+      patchShowAds();
+      globalGapFixInit();
+      ensurePreloadObserver();
+      ensureDomObserver();
+
+      insertHeroAdEarly().catch(() => {});
+      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 + '.ezoicNbb').join(' '),            ()  => {
-      if (!isBlocked()) { burst(); setTimeout(schedulePileFix, 80); setTimeout(schedulePileFix, 500); }
+
+    // Some setups populate content in multiple phases; ensure we re-scan.
+    $(window).on('action:ajaxify.contentLoaded.ezoicInfinite', () => {
+      if (isBlocked()) return;
+      requestBurst();
     });
+
+    $(window).on(
+      'action:posts.loaded.ezoicInfinite action:topics.loaded.ezoicInfinite action:categories.loaded.ezoicInfinite action:category.loaded.ezoicInfinite action:topic.loaded.ezoicInfinite',
+      () => {
+        if (isBlocked()) return;
+        requestBurst();
+      }
+    );
+
+    // Also listen through NodeBB's AMD hooks module when available.
     try {
-      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) {}
+      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'].forEach((ev) => {
+          try { hooks.on(ev, () => { if (!isBlocked()) requestBurst(); }); } catch (e) {}
+        });
       });
     } catch (e) {}
   }
@@ -1015,35 +1470,233 @@
   function bindScroll() {
     let ticking = false;
     window.addEventListener('scroll', () => {
-      // Fast-scroll boost: widen IO margins.
+      // Fast-scroll boost
       try {
-        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();
+        const t = now();
+        const 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) {
+            const speed = dy / dt;
+            if (speed >= BOOST_SPEED_PX_PER_MS) {
+              const wasBoosted = isBoosted();
+              state.scrollBoostUntil = Math.max(state.scrollBoostUntil || 0, t + BOOST_DURATION_MS);
+              if (!wasBoosted) ensurePreloadObserver();
+            }
           }
         }
-        st.lastScrollY = y; st.lastScrollTs = t;
+        state.lastScrollY = y;
+        state.lastScrollTs = t;
       } catch (e) {}
 
       if (ticking) return;
       ticking = true;
-      requestAnimationFrame(() => { ticking = false; burst(); });
+      requestAnimationFrame(() => {
+        ticking = false;
+        requestBurst();
+      });
     }, { passive: true });
   }
 
-  // ─── Boot ────────────────────────────────────────────────────────────────────
+  // ---------------- boot ----------------
+
+  state.pageKey = getPageKey();
+  muteNoisyConsole();
+  ensureTcfApiLocator();
+  warmUpNetwork();
+  patchShowAds();
+  ensurePreloadObserver();
+  ensureDomObserver();
+
+  bindNodeBB();
+  bindScroll();
 
-  st.pageKey = getPageKey();
-  muteConsole(); warmNetwork(); patchShowAds();
-  ensureIO(); ensureDomObs();
-  bindNodeBB(); bindScroll();
   blockedUntil = 0;
-  heroAd().catch(() => {});
-  burst();
-  schedulePileFix();
+  insertHeroAdEarly().catch(() => {});
+  requestBurst();
+})();
+
 
+
+// ===== V17 minimal pile-fix (no insert hooks) =====
+(function () {
+  // Goal: keep ad injection intact. Only repair when we detect "pile-up" of between wraps.
+  var TOPIC_LI_SEL = 'li[component="category/topic"]';
+  var BETWEEN_WRAP_SEL = 'div.nodebb-ezoic-wrap.ezoic-ad-between';
+  var HOST_CLASS = 'nodebb-ezoic-host';
+
+  var scheduled = false;
+  var lastRun = 0;
+  var COOLDOWN = 180;
+
+  function getTopicList() {
+    try {
+      var li = document.querySelector(TOPIC_LI_SEL);
+      if (!li) return null;
+      return li.closest ? li.closest('ul,ol') : null;
+    } catch (e) { return null; }
+  }
+
+  function isHost(node) {
+    return !!(node && node.nodeType === 1 && node.tagName === 'LI' && node.classList && node.classList.contains(HOST_CLASS));
+  }
+
+  function ensureHostForWrap(wrap, ul) {
+    try {
+      if (!wrap || wrap.nodeType !== 1) return null;
+      if (!(wrap.matches && wrap.matches(BETWEEN_WRAP_SEL))) return null;
+
+      var host = wrap.closest ? wrap.closest('li.' + HOST_CLASS) : null;
+      if (host) return host;
+
+      if (!ul) ul = wrap.closest ? wrap.closest('ul,ol') : null;
+      if (!ul || !(ul.tagName === 'UL' || ul.tagName === 'OL')) return null;
+
+      // Only wrap if direct child of list (invalid / fragile)
+      if (wrap.parentElement === ul) {
+        host = document.createElement('li');
+        host.className = HOST_CLASS;
+        host.setAttribute('role', 'listitem');
+        host.style.listStyle = 'none';
+        host.style.width = '100%';
+        ul.insertBefore(host, wrap);
+        host.appendChild(wrap);
+        try { wrap.style.width = '100%'; } catch (e) {}
+        return host;
+      }
+    } catch (e) {}
+    return null;
+  }
+
+  function previousTopicLi(node) {
+    try {
+      var prev = node.previousElementSibling;
+      while (prev) {
+        if (prev.matches && prev.matches(TOPIC_LI_SEL)) return prev;
+        // skip other hosts/wraps
+        prev = prev.previousElementSibling;
+      }
+    } catch (e) {}
+    return null;
+  }
+
+  function detectPileUp(ul) {
+    // Pile-up signature: 2+ between wraps/hosts adjacent with no topics between, often near top.
+    try {
+      var kids = ul.children;
+      var run = 0;
+      var maxRun = 0;
+      for (var i = 0; i < kids.length; i++) {
+        var el = kids[i];
+        var isBetween = false;
+        if (isHost(el)) {
+          isBetween = !!(el.querySelector && el.querySelector(BETWEEN_WRAP_SEL));
+        } else if (el.matches && el.matches(BETWEEN_WRAP_SEL)) {
+          isBetween = true;
+        }
+        if (isBetween) {
+          run++;
+          if (run > maxRun) maxRun = run;
+        } else if (el.matches && el.matches(TOPIC_LI_SEL)) {
+          run = 0;
+        } else {
+          // other nodes reset lightly
+          run = 0;
+        }
+      }
+      return maxRun >= 2;
+    } catch (e) {}
+    return false;
+  }
+
+  function redistribute(ul) {
+    try {
+      if (!ul) return;
+
+      // Step 1: wrap any direct child between DIVs into LI hosts (makes list stable)
+      ul.querySelectorAll(':scope > ' + BETWEEN_WRAP_SEL).forEach(function(w){ ensureHostForWrap(w, ul); });
+
+      // Step 2: only act if we see pile-up (avoid touching infinite scroll during normal flow)
+      if (!detectPileUp(ul)) return;
+
+      // Move each host to immediately after the closest previous topic LI at its current position.
+      var hosts = ul.querySelectorAll(':scope > li.' + HOST_CLASS);
+      hosts.forEach(function(host){
+        try {
+          var wrap = host.querySelector && host.querySelector(BETWEEN_WRAP_SEL);
+          if (!wrap) return;
+
+          var anchor = previousTopicLi(host);
+          if (!anchor) return; // if none, don't move (prevents yanking to top/bottom)
+
+          if (host.previousElementSibling !== anchor) {
+            anchor.insertAdjacentElement('afterend', host);
+          }
+        } catch (e) {}
+      });
+    } catch (e) {}
+  }
+
+  function schedule(reason) {
+    var now = Date.now();
+    if (now - lastRun < COOLDOWN) return;
+    if (scheduled) return;
+    scheduled = true;
+    requestAnimationFrame(function () {
+      scheduled = false;
+      lastRun = Date.now();
+      try {
+        var ul = getTopicList();
+        if (!ul) return;
+        redistribute(ul);
+      } catch (e) {}
+    });
+  }
+
+  function init() {
+    schedule('init');
+
+    // Observe only the topic list once available
+    try {
+      if (typeof MutationObserver !== 'undefined') {
+        var observeList = function(ul){
+          if (!ul) return;
+          var mo = new MutationObserver(function(muts){
+            // schedule on any change; redistribute() itself is guarded by pile-up detection
+            schedule('mo');
+          });
+          mo.observe(ul, { childList: true, subtree: true });
+        };
+
+        var ul = getTopicList();
+        if (ul) observeList(ul);
+        else {
+          var mo2 = new MutationObserver(function(){
+            var u2 = getTopicList();
+            if (u2) {
+              try { observeList(u2); } catch(e){}
+              try { mo2.disconnect(); } catch(e){}
+            }
+          });
+          mo2.observe(document.documentElement || document.body, { childList: true, subtree: true });
+        }
+      }
+    } catch (e) {}
+
+    // NodeBB events: run after infinite scroll batches
+    if (window.jQuery) {
+      try {
+        window.jQuery(window).on('action:ajaxify.end action:infiniteScroll.loaded', function(){
+          setTimeout(function(){ schedule('event'); }, 50);
+          setTimeout(function(){ schedule('event2'); }, 400);
+        });
+      } catch (e) {}
+    }
+  }
+
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', init);
+  else init();
 })();
+// ===== /V17 =====
+