nodebb-plugin-ezoic-infinite 1.6.97 → 1.6.98

package/public/client.js

@@ -1,135 +1,1694 @@
 (function () {
   'use strict';
 
-  if (window.ezInfiniteInjected) return;
-  window.ezInfiniteInjected = true;
+  // 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';
-  let config = null;
-  let isInternalChange = false;
-  let activeIds = new Set();
-
-  function getPool() {
-    let p = document.getElementById(POOL_ID);
-    if (!p) {
-      p = document.createElement('div');
-      p.id = POOL_ID;
-      p.style.display = 'none';
-      document.body.appendChild(p);
-    }
-    return p;
-  }
-
-  function callEzoic(id) {
-    if (typeof window.ezstandalone === 'undefined') return;
-    const pid = parseInt(id, 10);
-    if (isNaN(pid)) return;
-
-    window.ezstandalone.cmd.push(function() {
-      window.ezstandalone.define(pid);
-      if (!window.ezstandalone.enabled) {
-        window.ezstandalone.enable();
-        window.ezstandalone.showAds();
-      } else {
-        window.ezstandalone.showAds(pid);
-      }
-      activeIds.add(pid);
+
+  // 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;
+
+  // 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(),
+
+    // observers / schedulers
+    domObs: null,
+    io: null,
+    ioMargin: null,
+
+    // internal mutations guard
+    internalDomChange: 0,
+
+    // 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,
+  };
+
+  // Soft block during navigation / heavy DOM churn
+  let blockedUntil = 0;
+  const insertingIds = new Set();
+
+  function now() { return Date.now(); }
+  function isBlocked() { return now() < blockedUntil; }
+
+  // ---------------- utils ----------------
+
+  function normalizeBool(v) {
+    return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
-  function redistribute() {
-    if (!config || config.excluded) return;
+  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);
+      }
+    }
+    return out;
+  }
 
-    // 1. Accueil / Catégories
-    const categoryItems = document.querySelectorAll('.category-item, [component="categories/category"]');
-    if (config.enableCategoryAds) process(Array.from(categoryItems), 'home', config.intervalCategories, config.showFirstCategoryAd, 'div');
+  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 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 isMobile() {
+    try { return window.innerWidth < 768; } catch (e) { return false; }
+  }
 
-    // 2. Liste des Topics (Harmony utilise des <li>)
-    const topicItems = document.querySelectorAll('li[component="category/topic"]');
-    if (config.enableBetweenAds) process(Array.from(topicItems), 'topic-list', config.intervalPosts, config.showFirstTopicAd, 'li');
+  function isBoosted() {
+    return now() < (state.scrollBoostUntil || 0);
+  }
+
+  function getPreloadRootMargin() {
+    if (isMobile()) return isBoosted() ? PRELOAD_MARGIN_MOBILE_BOOST : PRELOAD_MARGIN_MOBILE;
+    return isBoosted() ? PRELOAD_MARGIN_DESKTOP_BOOST : PRELOAD_MARGIN_DESKTOP;
+  }
 
-    // 3. Messages (Posts)
-    const postItems = document.querySelectorAll('[component="post"]');
-    if (config.enableMessageAds) process(Array.from(postItems), 'message', config.messageIntervalPosts, config.showFirstMessageAd, 'div');
+  function getMaxInflight() {
+    const base = isMobile() ? MAX_INFLIGHT_MOBILE : MAX_INFLIGHT_DESKTOP;
+    return base + (isBoosted() ? 1 : 0);
   }
 
-  function process(items, kind, interval, showFirst, wrapperTag) {
-    const int = parseInt(interval, 10) || 10;
-    const pool = getPool();
+  function withInternalDomChange(fn) {
+    state.internalDomChange++;
+    try { fn(); } finally { state.internalDomChange--; }
+  }
 
-    items.forEach((item, index) => {
-      const pos = index + 1;
-      const shouldHaveAd = (pos === 1 && showFirst) || (pos % int === 0);
-      const next = item.nextElementSibling;
+  // ---------------- DOM helpers ----------------
 
-      if (shouldHaveAd && !(next && next.classList.contains(WRAP_CLASS))) {
-        const available = pool.querySelector(`[data-kind="${kind}"]`);
-        if (available) {
-          isInternalChange = true;
-          
-          // Création d'un conteneur qui respecte le type de parent (li ou div)
-          const wrapper = document.createElement(wrapperTag);
-          wrapper.className = WRAP_CLASS + ' ezoic-added-content';
-          wrapper.setAttribute('data-kind', kind);
-          wrapper.setAttribute('data-placeholder-id', available.getAttribute('data-placeholder-id'));
-          wrapper.innerHTML = available.innerHTML;
+  function getTopicItems() {
+    return Array.from(document.querySelectorAll(SELECTORS.topicItem));
+  }
 
-          item.parentNode.insertBefore(wrapper, item.nextSibling);
-          callEzoic(available.getAttribute('data-placeholder-id'));
-          
-          setTimeout(() => { isInternalChange = false; }, 50);
-        }
+  function getCategoryItems() {
+    return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
+  }
+
+  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;
+    });
+  }
+
+  function getKind() {
+    const p = window.location.pathname || '';
+    if (/^\/topic\//.test(p)) return 'topic';
+    if (/^\/category\//.test(p)) return 'categoryTopics';
+    if (p === '/' || /^\/categories/.test(p)) return 'categories';
+
+    if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
+    if (document.querySelector(SELECTORS.postItem)) return 'topic';
+    if (document.querySelector(SELECTORS.topicItem)) return 'categoryTopics';
+    return 'other';
+  }
+
+  function isAdjacentAd(target) {
+    if (!target) return false;
+    const next = target.nextElementSibling;
+    if (next && next.classList && next.classList.contains(WRAP_CLASS)) return true;
+    const prev = target.previousElementSibling;
+    if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) return true;
+    return false;
+  }
+
+  function findWrap(kindClass, afterPos) {
+    return document.querySelector(`.${WRAP_CLASS}.${kindClass}[data-ezoic-after="${afterPos}"]`);
+  }
+
+  // ---------------- placeholder pool ----------------
+
+  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 (!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) {}
+  }
+
+  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) {}
+  }
+
+  // ---------------- 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 applyPatch = () => {
+      try {
+        window.ezstandalone = window.ezstandalone || {};
+        const ez = window.ezstandalone;
+        if (window.__nodebbEzoicPatched) return;
+        if (typeof ez.showAds !== 'function') return;
+
+        window.__nodebbEzoicPatched = true;
+        const orig = ez.showAds;
+
+        ez.showAds = function (...args) {
+          if (isBlocked()) return;
+
+          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}`);
+            if (!ph || !ph.isConnected) continue;
+            seen.add(id);
+            try { orig.call(ez, id); } catch (e) {}
+          }
+        };
+      } catch (e) {}
+    };
+
+    applyPatch();
+    if (!window.__nodebbEzoicPatched) {
+      try {
+        window.ezstandalone = window.ezstandalone || {};
+        window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+        window.ezstandalone.cmd.push(applyPatch);
+      } catch (e) {}
+    }
+  }
+
+  // ---------------- config ----------------
+
+  async function fetchConfigOnce() {
+    if (state.cfg) return state.cfg;
+    try {
+      const res = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
+      if (!res.ok) return null;
+      state.cfg = await res.json();
+      return state.cfg;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  function initPools(cfg) {
+    if (!cfg) return;
+    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.
+  }
+
+  // ---------------- insertion primitives ----------------
+
+  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%';
+
+    if (createPlaceholder) {
+      const ph = document.createElement('div');
+      ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+      ph.setAttribute('data-ezoic-id', String(id));
+      wrap.appendChild(ph);
+    }
+
+    return wrap;
+  }
+
+  function insertAfter(target, id, kindClass, afterPos) {
+    if (!target || !target.insertAdjacentElement) return null;
+    if (findWrap(kindClass, afterPos)) return null;
+    if (insertingIds.has(id)) return null;
+
+    const existingPh = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+
+    insertingIds.add(id);
+    try {
+      const wrap = buildWrap(id, kindClass, afterPos, !existingPh);
+      target.insertAdjacentElement('afterend', wrap);
+
+      // If 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) {}
+      }
+
+      return wrap;
+    } finally {
+      insertingIds.delete(id);
+    }
+  }
+
+  function pickIdFromAll(allIds, cursorKey) {
+    const n = allIds.length;
+    if (!n) return null;
+
+    for (let tries = 0; tries < n; tries++) {
+      const idx = state[cursorKey] % n;
+      state[cursorKey] = (state[cursorKey] + 1) % n;
+      const id = allIds[idx];
+
+      const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+      if (ph && ph.isConnected && !isInPool(ph)) continue;
+
+      return id;
+    }
+
+    return null;
+  }
+
+  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]'));
+    };
+
+    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;
+    };
+
+    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++;
     });
+
+    return removed;
   }
 
-  function init() {
-    fetch('/api/plugins/ezoic-infinite/config')
-      .then(r => r.json())
-      .then(data => {
-        config = data;
-        const pool = getPool();
-        const setup = (raw, kind) => {
-          if (!raw) return;
-          raw.split(/[\s,]+/).filter(Boolean).forEach(id => {
-            const d = document.createElement('div');
-            d.setAttribute('data-kind', kind);
-            d.setAttribute('data-placeholder-id', id);
-            d.innerHTML = `<div id="ezoic-pub-ad-placeholder-${id}"></div>`;
-            pool.appendChild(d);
-          });
+  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;
+      }
+    };
+
+    let removed = 0;
+    for (const w of wraps) {
+      // Never decluster pinned placements.
+      try {
+        if (w.getAttribute && w.getAttribute('data-ezoic-pin') === '1') continue;
+      } 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) {}
+
+          // 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);
+
+          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 removed;
+  }
+
+  // ---------------- 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;
+    }
+
+    try {
+      state.io = new IntersectionObserver((entries) => {
+        for (const ent of entries) {
+          if (!ent.isIntersecting) continue;
+          const el = ent.target;
+          try { state.io && state.io.unobserve(el); } catch (e) {}
+
+          const idAttr = el && el.getAttribute && el.getAttribute('data-ezoic-id');
+          const id = parseInt(idAttr, 10);
+          if (Number.isFinite(id) && id > 0) enqueueShow(id);
+        }
+      }, { 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 observePlaceholder(id) {
+    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+    if (!ph || !ph.isConnected) return;
+    ph.setAttribute('data-ezoic-id', String(id));
+
+    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 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) {}
+  }
+
+  function enqueueShow(id) {
+    if (!id || isBlocked()) return;
+
+    // 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;
+    const max = getMaxInflight();
+    while (state.inflight < max && state.pending.length) {
+      const id = state.pending.shift();
+      state.pendingSet.delete(id);
+      startShow(id);
+    }
+  }
+
+  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;
+
+      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 created = parseInt(w2.getAttribute('data-created') || '0', 10);
+            if (created && (now() - created) < keepEmptyWrapMs()) return;
+          } catch (e) {}
+
+          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;
+
+    state.inflight++;
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      state.inflight = Math.max(0, state.inflight - 1);
+      drainQueue();
+    };
+
+    const hardTimer = setTimeout(release, 6500);
+
+    requestAnimationFrame(() => {
+      try {
+        if (isBlocked()) return;
+
+        const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+        if (!ph || !ph.isConnected) return;
+
+        // 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) {}
+          try { markEmptyWrapper(id); } catch (e) {}
+          try {
+            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(hardTimer); release(); }, 650);
         };
-        setup(config.categoryPlaceholderIds, 'home');
-        setup(config.placeholderIds, 'topic-list');
-        setup(config.messagePlaceholderIds, 'message');
-        
-        redistribute();
-
-        const observer = new MutationObserver(() => {
-          if (!isInternalChange) redistribute();
+
+        if (Array.isArray(ez.cmd)) {
+          try { ez.cmd.push(doShow); } catch (e) { doShow(); }
+        } else {
+          doShow();
+        }
+      } finally {
+        // hardTimer releases on early return
+      }
+    });
+  }
+
+  // ---------------- core injection ----------------
+
+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 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 injectBetween(kindClass, items, interval, showFirst, allIds, cursorKey) {
+    if (!items.length) return 0;
+
+    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 afterPos of targets) {
+      if (inserted >= maxInserts) break;
+      const el = ordinalMap.get(afterPos);
+      if (!el) continue;
+      if (!el || !el.isConnected) continue;
+      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') || '';
+        }
+      }
+
+      if (!id) break;
+
+      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 inserted;
+  }
+
+  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;
+  }
+
+  function moveWrapAfter(anchorEl, wrap, kindClass, afterPos) {
+    try {
+      if (!anchorEl || !wrap || !wrap.isConnected) return null;
+
+      wrap.setAttribute('data-ezoic-after', String(afterPos));
+      anchorEl.insertAdjacentElement('afterend', wrap);
+
+      // Ensure minimal layout impact.
+      try { wrap.style.contain = 'layout style paint'; } catch (e) {}
+      try { tightenStickyIn(wrap); } catch (e) {}
+      return wrap;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  async function runCore() {
+    if (isBlocked()) return 0;
+
+    patchShowAds();
+
+    const cfg = await fetchConfigOnce();
+    if (!cfg || cfg.excluded) return 0;
+    initPools(cfg);
+
+    const kind = getKind();
+    let inserted = 0;
+
+    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;
+  }
+
+  async function insertHeroAdEarly() {
+    if (state.heroDoneForPage || isBlocked()) return;
+
+    const cfg = await fetchConfigOnce();
+    if (!cfg || cfg.excluded) return;
+    initPools(cfg);
+
+    const kind = getKind();
+
+    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) return;
+    if (!showFirst) { state.heroDoneForPage = true; return; }
+
+    const afterPos = 1;
+    const el = items[0];
+    if (!el || !el.isConnected) return;
+    if (isAdjacentAd(el)) return;
+    if (findWrap(kindClass, afterPos)) { state.heroDoneForPage = true; return; }
+
+    const id = pickIdFromAll(allIds, cursorKey);
+    if (!id) return;
+
+    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);
+    startShowQueue();
+  }
+
+  // ---------------- scheduler ----------------
+
+  function scheduleRun(delayMs = 0, cb) {
+    if (state.runQueued) return;
+    state.runQueued = true;
+
+    const run = async () => {
+      state.runQueued = false;
+      const pk = getPageKey();
+      if (state.pageKey && pk !== state.pageKey) return;
+      let inserted = 0;
+      try { inserted = await runCore(); } catch (e) { inserted = 0; }
+      try { cb && cb(inserted); } catch (e) {}
+    };
+
+    const doRun = () => requestAnimationFrame(run);
+    if (delayMs > 0) setTimeout(doRun, delayMs);
+    else doRun();
+  }
+
+  function requestBurst() {
+    if (isBlocked()) return;
+
+    const t = now();
+    if (t - state.lastBurstReqTs < 120) return;
+    state.lastBurstReqTs = t;
+
+    const pk = getPageKey();
+    state.pageKey = pk;
+
+    state.burstDeadline = t + 1800;
+    if (state.burstActive) return;
+
+    state.burstActive = true;
+    state.burstCount = 0;
+
+    const step = () => {
+      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 ----------------
+
+  function cleanup() {
+    blockedUntil = now() + 1200;
+
+    try {
+      document.querySelectorAll(`.${WRAP_CLASS}`).forEach((el) => releaseWrapNode(el));
+    } catch (e) {}
+
+    state.cfg = null;
+    state.allTopics = [];
+    state.allPosts = [];
+    state.allCategories = [];
+    state.curTopics = 0;
+    state.curPosts = 0;
+    state.curCategories = 0;
+    state.lastShowById.clear();
+
+    state.inflight = 0;
+    state.pending = [];
+    state.pendingSet.clear();
+
+    state.heroDoneForPage = false;
+
+    // keep observers alive
+  }
+
+  function shouldReactToMutations(mutations) {
+    // Fast filter: only react if relevant nodes were added/removed.
+    for (const m of mutations) {
+      if (!m.addedNodes || m.addedNodes.length === 0) continue;
+      for (const n of m.addedNodes) {
+        if (!n || n.nodeType !== 1) continue;
+        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 ensureDomObserver() {
+    if (state.domObs) return;
+
+    state.domObs = new MutationObserver((mutations) => {
+      if (state.internalDomChange > 0) return;
+      if (isBlocked()) return;
+      if (!shouldReactToMutations(mutations)) return;
+      requestBurst();
+    });
+
+    try {
+      state.domObs.observe(document.body, { childList: true, subtree: true });
+    } catch (e) {}
+  }
+
+  function bindNodeBB() {
+    if (!$) return;
+
+    $(window).off('.ezoicInfinite');
+
+    $(window).on('action:ajaxify.start.ezoicInfinite', () => {
+      cleanup();
+    });
+
+    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
+      state.pageKey = getPageKey();
+      blockedUntil = 0;
+
+      muteNoisyConsole();
+      ensureTcfApiLocator();
+      warmUpNetwork();
+      patchShowAds();
+      globalGapFixInit();
+      ensurePreloadObserver();
+      ensureDomObserver();
+
+      insertHeroAdEarly().catch(() => {});
+      requestBurst();
+    });
+
+    // 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 (!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) {}
         });
-        observer.observe(document.body, { childList: true, subtree: true });
       });
+    } catch (e) {}
   }
 
-  // GESTION NAVIGATION SANS RECHARGE (SPA)
-  window.addEventListener('action:ajaxify.start', function() {
-    if (typeof window.ezstandalone !== 'undefined' && activeIds.size > 0) {
-      window.ezstandalone.cmd.push(function() {
-        window.ezstandalone.destroyAll();
-        activeIds.clear();
+  function bindScroll() {
+    let ticking = false;
+    window.addEventListener('scroll', () => {
+      // Fast-scroll boost
+      try {
+        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();
+            }
+          }
+        }
+        state.lastScrollY = y;
+        state.lastScrollTs = t;
+      } catch (e) {}
+
+      if (ticking) return;
+      ticking = true;
+      requestAnimationFrame(() => {
+        ticking = false;
+        requestBurst();
       });
-    }
-  });
+    }, { passive: true });
+  }
+
+  // ---------------- boot ----------------
 
-  window.addEventListener('action:ajaxify.end', function() {
-    setTimeout(redistribute, 600);
-  });
+  state.pageKey = getPageKey();
+  muteNoisyConsole();
+  ensureTcfApiLocator();
+  warmUpNetwork();
+  patchShowAds();
+  ensurePreloadObserver();
+  ensureDomObserver();
 
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', init);
-  } else {
-    init();
+  bindNodeBB();
+  bindScroll();
+
+  blockedUntil = 0;
+  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 =====
+