nodebb-plugin-ezoic-infinite 1.6.59 → 1.6.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.6.59",
+  "version": "1.6.61",
   "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",
@@ -18,4 +18,4 @@
     "compatibility": "^4.0.0"
   },
   "private": false
-}
+}

package/public/client.js

@@ -1,87 +1,1172 @@
 (function () {
   'use strict';
 
-  const WRAP_CLASS = 'nodebb-ezoic-wrap';
+  // ─── Scroll direction tracker ───────────────────────────────────────────────
+  // Prevents aggressive recycling when the user scrolls upward.
+  let lastScrollY = 0;
+  let scrollDir = 1; // 1 = down, -1 = up
+  try {
+    lastScrollY = window.scrollY || 0;
+    window.addEventListener('scroll', () => {
+      const y = window.scrollY || 0;
+      const d = y - lastScrollY;
+      if (Math.abs(d) > 4) { scrollDir = d > 0 ? 1 : -1; lastScrollY = y; }
+    }, { passive: true });
+  } catch (e) {}
+
+  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
+
+  // ─── Constants ──────────────────────────────────────────────────────────────
+  const WRAP_CLASS         = 'nodebb-ezoic-wrap';
   const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
-  
-  let config = null;
-  let usedIds = new Set();
-  let isEzoicEnabled = false;
-  let isRefreshing = false;
-
-  // --- LOGIQUE SDK EZOIC ---
-  function callEzoic(newIds) {
-    if (!window.ezstandalone || !newIds.length) return;
-
-    try {
-      window.ezstandalone.define(newIds);
-
-      // Si c'est le TOUT PREMIER appel sur la page
-      if (!isEzoicEnabled && !window.ezstandalone.enabled) {
-        window.ezstandalone.enable();
-        window.ezstandalone.display();
-        isEzoicEnabled = true;
-      } 
-      // Sinon, on utilise refresh MAIS avec un verrou de sécurité
-      else if (isEzoicEnabled && !isRefreshing) {
-        isRefreshing = true;
-        setTimeout(() => {
-          window.ezstandalone.refresh();
-          isRefreshing = false;
-        }, 500); // Délai de 500ms pour laisser le SDK respirer
-      }
-    } catch (e) { console.warn('[Ezoic] Error:', e); }
-  }
-
-  // --- INJECTION ---
-  function inject() {
-    if (!config || config.excluded) return;
-    const ul = document.querySelector('[component="topic/list"], [component="category"]');
-    if (!ul) return;
-
-    const items = Array.from(ul.children).filter(c => c.tagName === 'LI' && !c.classList.contains(WRAP_CLASS));
-    const newIdsFound = [];
-    const interval = parseInt(config.intervalPosts, 10) || 5;
-
-    items.forEach((li, idx) => {
-      const pos = idx + 1;
-      if (pos % interval === 0 && !li.nextElementSibling?.classList.contains(WRAP_CLASS)) {
-        const id = getNextId(config.placeholderIds);
-        if (id) {
-          const wrap = document.createElement('div');
-          wrap.className = WRAP_CLASS;
-          wrap.innerHTML = `<div id="${PLACEHOLDER_PREFIX}${id}"></div>`;
-          li.after(wrap);
-          newIdsFound.push(parseInt(id, 10));
+  const HOST_CLASS         = 'nodebb-ezoic-host';
+  const MAX_INSERTS_PER_RUN = 8;
+
+  function keepEmptyWrapMs() { return isMobile() ? 120_000 : 60_000; }
+
+  const PRELOAD_MARGIN_DESKTOP        = '2600px 0px 2600px 0px';
+  const PRELOAD_MARGIN_MOBILE         = '3200px 0px 3200px 0px';
+  const PRELOAD_MARGIN_DESKTOP_BOOST  = '5200px 0px 5200px 0px';
+  const PRELOAD_MARGIN_MOBILE_BOOST   = '5200px 0px 5200px 0px';
+  const BOOST_DURATION_MS             = 2500;
+  const BOOST_SPEED_PX_PER_MS         = 2.2;
+  const MAX_INFLIGHT_DESKTOP          = 4;
+  const MAX_INFLIGHT_MOBILE           = 3;
+
+  const SELECTORS = {
+    topicItem:    'li[component="category/topic"]',
+    postItem:     '[component="post"][data-pid]',
+    categoryItem: 'li[component="categories/category"]',
+  };
+
+  // ─── Shared helpers ─────────────────────────────────────────────────────────
+
+  function now()      { return Date.now(); }
+  function isMobile() { try { return window.innerWidth < 768; } catch (e) { return false; } }
+  function isBoosted(){ return now() < (state.scrollBoostUntil || 0); }
+
+  function normalizeBool(v) {
+    return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
+  }
+
+  /** Returns true if the node contains a rendered ad creative. */
+  function isFilled(node) {
+    return !!(node && node.querySelector &&
+      node.querySelector('iframe, ins, img, video, [data-google-container-id]'));
+  }
+
+  // ─── Console noise filter ───────────────────────────────────────────────────
+  function muteNoisyConsole() {
+    try {
+      if (window.__nodebbEzoicConsoleMuted) return;
+      window.__nodebbEzoicConsoleMuted = true;
+      const shouldMute = (args) => {
+        try {
+          const s = typeof args[0] === 'string' ? args[0] : '';
+          return (
+            (s.includes('[EzoicAds JS]: Placeholder Id') && s.includes('has already been defined')) ||
+            s.includes('Debugger iframe already exists') ||
+            (s.includes('HTML element with id ezoic-pub-ad-placeholder-') && s.includes('does not exist'))
+          );
+        } catch (e) { return false; }
+      };
+      const wrap = (m) => {
+        const orig = console[m];
+        if (typeof orig !== 'function') return;
+        console[m] = function (...a) { if (shouldMute(a)) return; return orig.apply(console, a); };
+      };
+      ['log','info','warn','error'].forEach(wrap);
+    } catch (e) {}
+  }
+
+  // ─── CMP/TCF stability ──────────────────────────────────────────────────────
+  function ensureTcfApiLocator() {
+    try {
+      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 = f.name = '__tcfapiLocator';
+      (document.body || document.documentElement).appendChild(f);
+    } catch (e) {}
+  }
+
+  // ─── Ezoic min-height tightener ─────────────────────────────────────────────
+  // Ezoic injects `min-height:400px !important` on nested wrappers via inline
+  // style. CSS alone can't fix it — we must rewrite the inline style.
+  function tightenEzoicMinHeight(wrap) {
+    try {
+      if (!wrap || !wrap.querySelector) return;
+      const iframes = wrap.querySelectorAll('iframe');
+      if (!iframes.length) return;
+
+      let refNode = null;
+      let p = iframes[0].parentElement;
+      while (p && p !== wrap) {
+        if (p.classList && p.classList.contains('ezoic-ad')) {
+          const st = (p.getAttribute('style') || '').toLowerCase();
+          if (st.includes('min-height:400') || st.includes('min-height: 400')) { refNode = p; break; }
+        }
+        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) {}
+
+      let maxBottom = 0;
+      iframes.forEach((f) => {
+        const rect = f.getBoundingClientRect();
+        if (rect.width <= 1 || rect.height <= 1) return;
+        maxBottom = Math.max(maxBottom, rect.bottom - refTop);
+      });
+      if (!maxBottom) {
+        iframes.forEach((f) => {
+          maxBottom = Math.max(maxBottom, parseInt(f.getAttribute('height') || '0', 10), f.offsetHeight || 0);
+        });
+      }
+      if (!maxBottom) return;
+
+      const h = Math.max(1, Math.ceil(maxBottom));
+      const tightenNode = (n) => {
+        if (!n || !n.style) return;
+        try { n.style.setProperty('min-height', h + 'px', 'important'); } catch (e) { n.style.minHeight = h + 'px'; }
+        try { n.style.setProperty('height', 'auto', 'important'); } catch (e) {}
+        try { n.style.setProperty('line-height', '0', 'important'); } catch (e) {}
+      };
+
+      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')) tightenNode(cur);
         }
+        cur = cur.parentElement;
       }
+      tightenNode(refNode);
+      refNode.querySelectorAll('.ezoic-ad[style*="min-height"], .ezoic-ad-adaptive').forEach((n) => {
+        const st = (n.getAttribute('style') || '').toLowerCase();
+        if (st.includes('min-height:400') || st.includes('min-height: 400')) tightenNode(n);
+      });
+      if (isMobile()) {
+        try { refNode.style.setProperty('width',     '100%', 'important'); } catch (e) {}
+        try { refNode.style.setProperty('max-width', '100%', 'important'); } catch (e) {}
+        try { refNode.style.setProperty('min-width', '0',    'important'); } catch (e) {}
+      }
+    } catch (e) {}
+  }
+
+  function watchWrapForFill(wrap) {
+    try {
+      if (!wrap || wrap.__ezFillObs) return;
+      const start = now();
+      const tightenBurst = () => {
+        try { tightenEzoicMinHeight(wrap); } catch (e) {}
+        if (now() - start < 6000) setTimeout(tightenBurst, 350);
+      };
+      const obs = new MutationObserver((muts) => {
+        if (isFilled(wrap)) { wrap.classList.remove('is-empty'); tightenBurst(); }
+        for (const m of muts) {
+          if (m.type === 'attributes' && m.attributeName === 'style') {
+            try { tightenEzoicMinHeight(wrap); } catch (e) {}
+            break;
+          }
+        }
+        if (now() - start > 7000) { try { obs.disconnect(); } catch (e) {} wrap.__ezFillObs = null; }
+      });
+      obs.observe(wrap, { childList: true, subtree: true, attributes: true, attributeFilter: ['style'] });
+      wrap.__ezFillObs = obs;
+    } catch (e) {}
+  }
+
+  function globalGapFixInit() {
+    try {
+      if (window.__nodebbEzoicGapFix) return;
+      window.__nodebbEzoicGapFix = true;
+      const root = document.getElementById('content') ||
+        document.querySelector('[component="content"], #panel') || document.body;
+      const inPostArea = (el) => {
+        try { return !!(el && el.closest && el.closest('[component="post"], .topic, .posts, [component="topic"]')); }
+        catch (e) { return false; }
+      };
+      const maybeFix = (r) => {
+        if (!r || !r.querySelectorAll) return;
+        r.querySelectorAll('.ezoic-ad[style*="min-height"], .ezoic-ad-adaptive[style*="min-height"]')
+          .forEach((n) => {
+            const st = (n.getAttribute('style') || '').toLowerCase();
+            if (!st.includes('min-height:400')) return;
+            if (!inPostArea(n)) return;
+            try { tightenEzoicMinHeight(n.closest('.' + WRAP_CLASS) || n.parentElement || n); } catch (e) {}
+          });
+      };
+      requestAnimationFrame(() => maybeFix(root));
+      const pending = new Set();
+      let scheduled = false;
+      const flush = () => {
+        scheduled = false;
+        pending.forEach((n) => { try { maybeFix(n); } catch (e) {} });
+        pending.clear();
+      };
+      new MutationObserver((muts) => {
+        for (const m of muts) {
+          if (m.type === 'attributes') {
+            const t = m.target && m.target.nodeType === 1 ? m.target : m.target && m.target.parentElement;
+            if (t) pending.add(t);
+          } else if (m.addedNodes) {
+            m.addedNodes.forEach((n) => { if (n && n.nodeType === 1) pending.add(n); });
+          }
+        }
+        if (pending.size && !scheduled) { scheduled = true; requestAnimationFrame(flush); }
+      }).observe(root, { subtree: true, childList: true, attributes: true, attributeFilter: ['style'] });
+    } catch (e) {}
+  }
+
+  // ─── State ──────────────────────────────────────────────────────────────────
+  const state = {
+    pageKey: null, cfg: null,
+    allTopics: [], allPosts: [], allCategories: [],
+    curTopics: 0, curPosts: 0, curCategories: 0,
+    lastShowById: new Map(),
+    domObs: null, io: null, ioMargin: null,
+    internalDomChange: 0,
+    inflight: 0, pending: [], pendingSet: new Set(),
+    scrollBoostUntil: 0, lastScrollY: 0, lastScrollTs: 0,
+    heroDoneForPage: false,
+    runQueued: false, burstActive: false, burstDeadline: 0, burstCount: 0, lastBurstReqTs: 0,
+  };
+
+  let blockedUntil = 0;
+  const insertingIds = new Set();
+  function isBlocked() { return now() < blockedUntil; }
+
+  // ─── Utils ──────────────────────────────────────────────────────────────────
+  function parsePool(raw) {
+    if (!raw) return [];
+    const seen = new Set(), out = [];
+    String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean).forEach((v) => {
+      const n = parseInt(v, 10);
+      if (Number.isFinite(n) && n > 0 && !seen.has(n)) { seen.add(n); out.push(n); }
+    });
+    return out;
+  }
+
+  function getPageKey() {
+    try {
+      const ax = window.ajaxify;
+      if (ax && ax.data) {
+        if (ax.data.tid) return 'topic:' + ax.data.tid;
+        if (ax.data.cid) return 'cid:' + ax.data.cid + ':' + window.location.pathname;
+      }
+    } catch (e) {}
+    return window.location.pathname;
+  }
+
+  function getPreloadRootMargin() {
+    return isMobile()
+      ? (isBoosted() ? PRELOAD_MARGIN_MOBILE_BOOST  : PRELOAD_MARGIN_MOBILE)
+      : (isBoosted() ? PRELOAD_MARGIN_DESKTOP_BOOST : PRELOAD_MARGIN_DESKTOP);
+  }
+
+  function getMaxInflight() {
+    return (isMobile() ? MAX_INFLIGHT_MOBILE : MAX_INFLIGHT_DESKTOP) + (isBoosted() ? 1 : 0);
+  }
+
+  function withInternalDomChange(fn) {
+    state.internalDomChange++;
+    try { fn(); } finally { state.internalDomChange--; }
+  }
+
+  // ─── DOM helpers ────────────────────────────────────────────────────────────
+  function getTopicItems()    { return Array.from(document.querySelectorAll(SELECTORS.topicItem)); }
+  function getCategoryItems() { return Array.from(document.querySelectorAll(SELECTORS.categoryItem)); }
+
+  function getPostContainers() {
+    return Array.from(document.querySelectorAll(SELECTORS.postItem)).filter((el) => {
+      if (!el.isConnected) return false;
+      if (!el.querySelector('[component="post/content"]')) return false;
+      const pp = el.parentElement && el.parentElement.closest('[component="post"][data-pid]');
+      if (pp && pp !== el) return false;
+      if (el.getAttribute('component') === 'post/parent') return false;
+      return true;
     });
+  }
+
+  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 + '"]');
+  }
 
-    if (newIdsFound.length > 0) {
-      callEzoic(newIdsFound);
+  // ─── Network warmup ─────────────────────────────────────────────────────────
+  const _warmLinksDone = new Set();
+  function warmUpNetwork() {
+    try {
+      const head = document.head || document.getElementsByTagName('head')[0];
+      if (!head) return;
+      [
+        ['preconnect',   'https://g.ezoic.net',                     true],
+        ['dns-prefetch', 'https://g.ezoic.net',                     false],
+        ['preconnect',   'https://go.ezoic.net',                    true],
+        ['dns-prefetch', 'https://go.ezoic.net',                    false],
+        ['preconnect',   'https://securepubads.g.doubleclick.net',  true],
+        ['dns-prefetch', 'https://securepubads.g.doubleclick.net',  false],
+        ['preconnect',   'https://pagead2.googlesyndication.com',   true],
+        ['dns-prefetch', 'https://pagead2.googlesyndication.com',   false],
+        ['preconnect',   'https://tpc.googlesyndication.com',       true],
+        ['dns-prefetch', 'https://tpc.googlesyndication.com',       false],
+      ].forEach(([rel, href, cors]) => {
+        const key = rel + '|' + href;
+        if (_warmLinksDone.has(key)) return;
+        _warmLinksDone.add(key);
+        const link = document.createElement('link');
+        link.rel = rel; link.href = href;
+        if (cors) link.crossOrigin = 'anonymous';
+        head.appendChild(link);
+      });
+    } catch (e) {}
+  }
+
+  // ─── Ezoic bridge ───────────────────────────────────────────────────────────
+  // Patch showAds so it silently skips IDs whose placeholder is not in the DOM.
+  function patchShowAds() {
+    const applyPatch = () => {
+      try {
+        window.ezstandalone = window.ezstandalone || {};
+        const ez = window.ezstandalone;
+        if (window.__nodebbEzoicPatched) return;
+        if (typeof ez.showAds !== 'function') return;
+        window.__nodebbEzoicPatched = true;
+        const orig = ez.showAds;
+        ez.showAds = function (...args) {
+          if (isBlocked()) return;
+          const ids = (args.length === 1 && Array.isArray(args[0])) ? args[0] : args;
+          const seen = new Set();
+          for (const v of ids) {
+            const id = parseInt(v, 10);
+            if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
+            const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
+            if (!ph || !ph.isConnected) continue;
+            seen.add(id);
+            try { orig.call(ez, id); } catch (e) {}
+          }
+        };
+      } catch (e) {}
+    };
+    applyPatch();
+    if (!window.__nodebbEzoicPatched) {
+      try {
+        window.ezstandalone = window.ezstandalone || {};
+        window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+        window.ezstandalone.cmd.push(applyPatch);
+      } catch (e) {}
     }
   }
 
-  function getNextId(pool) {
-    const ids = pool.split(/[\s,]+/).filter(Boolean);
-    for (const id of ids) {
-      const n = id.trim();
-      if (n && !usedIds.has(n)) {
-        usedIds.add(n);
-        return n;
+  // ─── 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;
+    // Pools are NOT pre-seeded into the DOM: connecting placeholders offscreen
+    // causes Ezoic to pre-define slots → "already defined" errors on SPA navigations.
+    if (!state.allTopics.length)     state.allTopics     = parsePool(cfg.placeholderIds);
+    if (!state.allPosts.length)      state.allPosts      = parsePool(cfg.messagePlaceholderIds);
+    if (!state.allCategories.length) state.allCategories = parsePool(cfg.categoryPlaceholderIds);
+  }
+
+  // ─── 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()));
+    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 (existingPh) {
+        existingPh.setAttribute('data-ezoic-id', String(id));
+        if (!wrap.firstElementChild) wrap.appendChild(existingPh);
+        else wrap.replaceChild(existingPh, wrap.firstElementChild);
       }
+      return wrap;
+    } finally {
+      insertingIds.delete(id);
+    }
+  }
+
+  function releaseWrapNode(wrap) {
+    try {
+      const ph = wrap && wrap.querySelector && wrap.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
+      if (ph) {
+        try { (document.body || document.documentElement).appendChild(ph); } catch (e) {}
+        try { state.io && state.io.unobserve(ph); } catch (e) {}
+      }
+    } catch (e) {}
+    try { wrap && wrap.remove && wrap.remove(); } catch (e) {}
+  }
+
+  function pickIdFromAll(allIds, cursorKey) {
+    const n = allIds.length;
+    if (!n) return null;
+    for (let tries = 0; tries < n; tries++) {
+      const idx = state[cursorKey] % n;
+      state[cursorKey] = (state[cursorKey] + 1) % n;
+      const id = allIds[idx];
+      const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
+      // Skip if placeholder is already mounted in a visible wrap.
+      if (ph && ph.isConnected && ph.closest('.' + WRAP_CLASS)) continue;
+      return id;
     }
     return null;
   }
 
-  async function init() {
-    const res = await fetch('/api/plugins/ezoic-infinite/config');
-    config = await res.json();
-    inject();
+  // ─── Orphan / cluster management ────────────────────────────────────────────
+  function pruneOrphanWraps(kindClass, items) {
+    if (!items || !items.length) return 0;
+    const itemSet  = new Set(items);
+    const isMessage = kindClass === 'ezoic-ad-message';
+    let removed = 0;
+
+    const hasNearbyItem = (wrap) => {
+      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;
+    };
+
+    document.querySelectorAll('.' + WRAP_CLASS + '.' + kindClass).forEach((wrap) => {
+      // Never touch pinned placements.
+      if (wrap.getAttribute('data-ezoic-pin') === '1') return;
+
+      // Never prune very fresh wraps (slow auction / CMP fills).
+      const created = parseInt(wrap.getAttribute('data-created') || '0', 10);
+      if (created && (now() - created) < keepEmptyWrapMs()) return;
+
+      if (hasNearbyItem(wrap)) {
+        try { wrap.classList.remove('ez-orphan-hidden'); wrap.style.display = ''; } catch (e) {}
+        return;
+      }
+
+      // Anchor is gone (virtualized) → hide so ads don't stack visually.
+      try { wrap.classList.add('ez-orphan-hidden'); wrap.style.display = 'none'; } catch (e) {}
+
+      // Only fully release when far off-screen (avoids perceived "vanishing").
+      // FIX: between-ads are now also subject to this offscreen check, not
+      // just message-ads. Previously, filled between-ad wraps were NEVER pruned,
+      // causing orphaned filled wraps to drift near the top of the list.
+      try {
+        const r   = wrap.getBoundingClientRect();
+        const vh  = Math.max(1, window.innerHeight || 1);
+        const near = isMessage
+          ? (r.bottom > -vh * 2 && r.top < vh * 4)
+          : (r.bottom > -vh * 3 && r.top < vh * 5);
+        if (near) return;
+      } catch (e) { return; }
+
+      withInternalDomChange(() => releaseWrapNode(wrap));
+      removed++;
+    });
+    return removed;
+  }
+
+  function decluster(kindClass) {
+    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 isFresh = (w)  => {
+      const c = parseInt(w.getAttribute('data-created') || '0', 10);
+      return c && (now() - c) < keepEmptyWrapMs();
+    };
+    let removed = 0;
+    for (const w of wraps) {
+      if (w.getAttribute && w.getAttribute('data-ezoic-pin') === '1') continue;
+      let prev = w.previousElementSibling;
+      for (let i = 0; i < 3 && prev; i++) {
+        if (isWrap(prev)) {
+          if (prev.getAttribute && prev.getAttribute('data-ezoic-pin') === '1') break;
+          const prevFilled = isFilled(prev);
+          const curFilled  = isFilled(w);
+          if (curFilled) {
+            if (!prevFilled && !isFresh(prev)) { withInternalDomChange(() => releaseWrapNode(prev)); removed++; }
+            break;
+          }
+          if (prevFilled || !isFresh(w)) { withInternalDomChange(() => releaseWrapNode(w)); removed++; }
+          break;
+        }
+        prev = prev.previousElementSibling;
+      }
+    }
+    return removed;
+  }
 
-    // Ecoute du scroll infini NodeBB
-    $(window).on('action:infiniteScroll.loaded', () => setTimeout(inject, 100));
+  // ─── Pile-up repair for between-ads ─────────────────────────────────────────
+  // When NodeBB's DOM structure requires between-ad DIVs to live inside a <ul>,
+  // they must be wrapped in a <li> host. This module also corrects position
+  // drift that occurs after infinite-scroll mutations.
+  //
+  // FIX (v18): replaced the previous blind `previousTopicLi()` DOM walk with
+  // anchor lookup via `data-ezoic-after` + topic `data-index`. The old approach
+  // was the ROOT CAUSE of ads piling below the first topic: during pile-up
+  // detection it moved ALL piled wraps to after the SAME first topic it found.
+  //
+  // Now each wrap is moved to after the specific topic whose ordinal matches
+  // the wrap's own `data-ezoic-after` attribute.
+
+  function pileFixGetTopicList() {
+    try {
+      const li = document.querySelector(SELECTORS.topicItem);
+      if (!li) return null;
+      return li.closest ? li.closest('ul,ol') : null;
+    } catch (e) { return null; }
+  }
+
+  function ensureHostForWrap(wrap, ul) {
+    try {
+      if (!wrap || wrap.nodeType !== 1) return null;
+      const wrapSel = 'div.' + WRAP_CLASS + '.ezoic-ad-between';
+      if (!wrap.matches || !wrap.matches(wrapSel)) return null;
+      const existing = wrap.closest ? wrap.closest('li.' + HOST_CLASS) : null;
+      if (existing) return existing;
+      if (!ul) ul = wrap.closest ? wrap.closest('ul,ol') : null;
+      if (!ul || !/^(UL|OL)$/i.test(ul.tagName)) return null;
+      if (wrap.parentElement !== ul) return null;
+      const host = document.createElement('li');
+      host.className = HOST_CLASS;
+      host.setAttribute('role', 'listitem');
+      host.style.cssText = 'list-style:none;width:100%;';
+      ul.insertBefore(host, wrap);
+      host.appendChild(wrap);
+      return host;
+    } catch (e) { return null; }
   }
 
-  $(document).ready(init);
-})();
+  function detectPileUp(ul) {
+    try {
+      let run = 0, maxRun = 0;
+      const kids = ul.children;
+      const wrapSel = 'div.' + WRAP_CLASS + '.ezoic-ad-between';
+      for (let i = 0; i < kids.length; i++) {
+        const el = kids[i];
+        const isHost    = el.tagName === 'LI' && el.classList && el.classList.contains(HOST_CLASS);
+        const isBetween = (isHost && el.querySelector && el.querySelector(wrapSel)) ||
+                          (el.matches && el.matches(wrapSel));
+        if (isBetween)                              { maxRun = Math.max(maxRun, ++run); }
+        else if (el.matches && el.matches(SELECTORS.topicItem)) { run = 0; }
+        else                                        { run = 0; }
+      }
+      return maxRun >= 2;
+    } catch (e) { return false; }
+  }
+
+  /**
+   * Move each pile-up host to after its correct anchor topic.
+   *
+   * Anchor is determined by matching the wrap's `data-ezoic-after` (1-based ordinal)
+   * against each topic LI's `data-index` (0-based) → ordinal = data-index + 1.
+   */
+  function redistributePileUp(ul) {
+    try {
+      if (!ul) return;
+      // Step 1: wrap bare between-ad DIVs that are direct <ul> children.
+      const wrapSel = 'div.' + WRAP_CLASS + '.ezoic-ad-between';
+      const directs = Array.from(ul.querySelectorAll(':scope > ' + wrapSel));
+      directs.forEach((w) => ensureHostForWrap(w, ul));
+
+      // Step 2: bail if no pile-up.
+      if (!detectPileUp(ul)) return;
+
+      // Step 3: build ordinal → topic LI map.
+      const topicLis = Array.from(ul.querySelectorAll(':scope > ' + SELECTORS.topicItem));
+      const ordinalMap = new Map();
+      topicLis.forEach((li, i) => {
+        const di  = li.dataset && (li.dataset.index !== undefined ? li.dataset.index : null);
+        const raw = di !== null && di !== undefined ? di : li.getAttribute('data-index');
+        const ord = (raw !== null && raw !== undefined && raw !== '' && !isNaN(raw))
+          ? parseInt(raw, 10) + 1   // data-index is 0-based; ordinals are 1-based
+          : i + 1;
+        ordinalMap.set(ord, li);
+      });
+
+      // Step 4: move each host to immediately after its correct anchor topic.
+      const hosts = Array.from(ul.querySelectorAll(':scope > li.' + HOST_CLASS));
+      hosts.forEach((host) => {
+        try {
+          const wrap = host.querySelector && host.querySelector(wrapSel);
+          if (!wrap) return;
+
+          const afterPos = parseInt(wrap.getAttribute('data-ezoic-after') || '0', 10);
+          if (!afterPos) return;
+
+          const anchor = ordinalMap.get(afterPos);
+          if (!anchor) return; // anchor topic not loaded yet — leave in place
+
+          if (host.previousElementSibling !== anchor) {
+            anchor.insertAdjacentElement('afterend', host);
+          }
+        } catch (e) {}
+      });
+    } catch (e) {}
+  }
+
+  let _pileFixScheduled = false;
+  let _pileFixLastRun   = 0;
+  const PILE_FIX_COOLDOWN = 180;
+
+  function schedulePileFix() {
+    if (now() - _pileFixLastRun < PILE_FIX_COOLDOWN) return;
+    if (_pileFixScheduled) return;
+    _pileFixScheduled = true;
+    requestAnimationFrame(() => {
+      _pileFixScheduled = false;
+      _pileFixLastRun   = now();
+      try { const ul = pileFixGetTopicList(); if (ul) redistributePileUp(ul); } catch (e) {}
+    });
+  }
+
+  function initPileFixObserver() {
+    try {
+      if (typeof MutationObserver === 'undefined') return;
+      const observe = (ul) => {
+        new MutationObserver(() => schedulePileFix())
+          .observe(ul, { childList: true, subtree: true });
+      };
+      const ul = pileFixGetTopicList();
+      if (ul) {
+        observe(ul);
+      } else {
+        const sentinel = new MutationObserver(() => {
+          const u = pileFixGetTopicList();
+          if (u) { try { sentinel.disconnect(); } catch (e) {} observe(u); }
+        });
+        sentinel.observe(document.documentElement || document.body, { childList: true, subtree: true });
+      }
+    } catch (e) {}
+  }
+
+  // ─── IntersectionObserver (preload / fast fill) ─────────────────────────────
+  function ensurePreloadObserver() {
+    const desiredMargin = getPreloadRootMargin();
+    if (state.io && state.ioMargin === desiredMargin) return state.io;
+
+    try { state.io && state.io.disconnect(); } catch (e) {}
+    state.io = null;
+
+    try {
+      state.io = new IntersectionObserver((entries) => {
+        for (const ent of entries) {
+          if (!ent.isIntersecting) continue;
+          const el = ent.target;
+          try { state.io && state.io.unobserve(el); } catch (e) {}
+          const id = parseInt(el && el.getAttribute && el.getAttribute('data-ezoic-id'), 10);
+          if (Number.isFinite(id) && id > 0) enqueueShow(id);
+        }
+      }, { root: null, rootMargin: desiredMargin, threshold: 0 });
+      state.ioMargin = desiredMargin;
+      document.querySelectorAll('[id^="' + PLACEHOLDER_PREFIX + '"]')
+        .forEach((n) => { try { state.io.observe(n); } catch (e) {} });
+    } catch (e) { state.io = state.ioMargin = null; }
+
+    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));
+    try { const io = ensurePreloadObserver(); io && io.observe(ph); } catch (e) {}
+    try {
+      const r = ph.getBoundingClientRect();
+      const mobile  = isMobile(), boosted = isBoosted();
+      const screens = boosted ? (mobile ? 9.0 : 5.0) : (mobile ? 6.0 : 3.0);
+      const minBot  = boosted ? (mobile ? -2600 : -1500) : (mobile ? -1400 : -800);
+      if (r.top < window.innerHeight * screens && r.bottom > minBot) enqueueShow(id);
+    } catch (e) {}
+  }
+
+  // ─── Show queue ─────────────────────────────────────────────────────────────
+  function enqueueShow(id) {
+    if (!id || isBlocked()) return;
+    const t = now();
+    if (t - (state.lastShowById.get(id) || 0) < 900) return;
+    const max = getMaxInflight();
+    if (state.inflight >= max) {
+      if (!state.pendingSet.has(id)) { state.pending.push(id); state.pendingSet.add(id); }
+      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) {
+    try {
+      const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
+      if (!ph || !ph.isConnected) return;
+      const wrap = ph.closest && ph.closest('.' + WRAP_CLASS);
+      if (!wrap) return;
+      setTimeout(() => {
+        try {
+          const ph2 = document.getElementById(PLACEHOLDER_PREFIX + id);
+          if (!ph2 || !ph2.isConnected) return;
+          const w2 = ph2.closest && ph2.closest('.' + WRAP_CLASS);
+          if (!w2) return;
+          const created = parseInt(w2.getAttribute('data-created') || '0', 10);
+          if (created && (now() - created) < keepEmptyWrapMs()) return;
+          if (!isFilled(ph2)) { w2.classList.add('is-empty'); watchWrapForFill(w2); }
+          else { w2.classList.remove('is-empty'); tightenEzoicMinHeight(w2); }
+        } catch (e) {}
+      }, 15_000);
+    } catch (e) {}
+  }
+
+  function 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 (isFilled(ph)) { clearTimeout(hardTimer); release(); return; }
+        const t = now();
+        if (t - (state.lastShowById.get(id) || 0) < 900) return;
+        state.lastShowById.set(id, t);
+        window.ezstandalone = window.ezstandalone || {};
+        const ez = window.ezstandalone;
+        const doShow = () => {
+          try { ez.showAds(id); } catch (e) {}
+          try { markEmptyWrapper(id); } catch (e) {}
+          try {
+            const ww = document.getElementById(PLACEHOLDER_PREFIX + id);
+            const w2 = ww && ww.closest && ww.closest('.' + WRAP_CLASS);
+            if (w2) {
+              watchWrapForFill(w2);
+              setTimeout(() => { try { tightenEzoicMinHeight(w2); } catch (e) {} }, 900);
+              setTimeout(() => { try { tightenEzoicMinHeight(w2); } catch (e) {} }, 2200);
+            }
+          } catch (e) {}
+          setTimeout(() => { clearTimeout(hardTimer); release(); }, 650);
+        };
+        if (Array.isArray(ez.cmd)) { try { ez.cmd.push(doShow); } catch (e) { doShow(); } }
+        else doShow();
+      } finally {
+        // hardTimer covers early returns.
+      }
+    });
+  }
+
+  // ─── 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 !== '' && !isNaN(di)) {
+        const n = parseInt(di, 10);
+        if (Number.isFinite(n) && n >= 0) return n + 1;
+      }
+      const d1 = el.getAttribute('data-idx') || el.getAttribute('data-position') ||
+                 (el.dataset && (el.dataset.idx || el.dataset.position));
+      if (d1 != null && d1 !== '' && !isNaN(d1)) {
+        const n = parseInt(d1, 10);
+        if (Number.isFinite(n) && n > 0) return n;
+      }
+    } catch (e) {}
+    return fallbackIndex + 1;
+  }
+
+  function buildOrdinalMap(items) {
+    const map = new Map();
+    let max = 0;
+    for (let i = 0; i < items.length; i++) {
+      const ord = getItemOrdinal(items[i], i);
+      map.set(ord, items[i]);
+      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); }
+    return Array.from(new Set(out)).sort((a, b) => a - b);
+  }
+
+  function pickRecyclableWrap(kindClass) {
+    const wraps = document.querySelectorAll('.' + kindClass + '[data-ezoic-wrapid]');
+    if (!wraps || !wraps.length) return null;
+    const vh        = Math.max(300, window.innerHeight || 800);
+    const threshold = -Math.min(9000, Math.round(vh * 6));
+    let best = null, bestBottom = Infinity;
+    for (const w of wraps) {
+      if (!w.isConnected) continue;
+      if (w.getAttribute('data-ezoic-pin') === '1') continue;
+      // FIX: do not recycle near-top wraps (afterPos ≤ 6).
+      // These are likely to be visible again when the user scrolls back up.
+      const afterPos = parseInt(w.getAttribute('data-ezoic-after') || '0', 10);
+      if (afterPos > 0 && afterPos <= 6) continue;
+      const rect = w.getBoundingClientRect();
+      if (rect.bottom < threshold && rect.bottom < bestBottom) {
+        bestBottom = rect.bottom;
+        best = w;
+      }
+    }
+    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);
+      try { wrap.style.contain = 'layout style paint'; } catch (e) {}
+      return wrap;
+    } catch (e) { return null; }
+  }
+
+  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);
+    const maxInserts = MAX_INSERTS_PER_RUN + (isBoosted() ? 1 : 0);
+    let inserted = 0;
+
+    for (const afterPos of targets) {
+      if (inserted >= maxInserts) break;
+      const el = ordinalMap.get(afterPos);
+      if (!el || !el.isConnected) continue;
+      if (isAdjacentAd(el)) continue;
+      if (findWrap(kindClass, afterPos)) continue;
+
+      let id = pickIdFromAll(allIds, cursorKey);
+      let recycledWrap = null;
+
+      if (!id) {
+        // Pool exhausted: try to recycle a wrap that is far above the viewport.
+        // Recycling is disabled when scrolling up and for message ads.
+        const allowRecycle = kindClass !== 'ezoic-ad-message' && scrollDir > 0;
+        recycledWrap = allowRecycle ? 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(id);
+      inserted++;
+    }
+    return inserted;
+  }
+
+  // ─── runCore ────────────────────────────────────────────────────────────────
+  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' && 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' && 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');
+      schedulePileFix();
+
+    } else if (kind === 'categories' && 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 (first item, early insert) ─────────────────────────────────────
+  async function insertHeroAdEarly() {
+    if (state.heroDoneForPage || isBlocked()) return;
+    const cfg = await fetchConfigOnce();
+    if (!cfg || cfg.excluded) return;
+    initPools(cfg);
+
+    const kind = getKind();
+    let items = [], allIds = [], cursorKey = '', kindClass = '', showFirst = false;
+
+    if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
+      items = getPostContainers(); allIds = state.allPosts; cursorKey = 'curPosts';
+      kindClass = 'ezoic-ad-message'; showFirst = normalizeBool(cfg.showFirstMessageAd);
+    } else if (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
+      items = getTopicItems(); allIds = state.allTopics; cursorKey = 'curTopics';
+      kindClass = 'ezoic-ad-between'; showFirst = normalizeBool(cfg.showFirstTopicAd);
+    } else if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
+      items = getCategoryItems(); allIds = state.allCategories; cursorKey = 'curCategories';
+      kindClass = 'ezoic-ad-categories'; showFirst = normalizeBool(cfg.showFirstCategoryAd);
+    } else { return; }
+
+    if (!items.length || !showFirst) { state.heroDoneForPage = true; return; }
+
+    const el = items[0];
+    if (!el || !el.isConnected || isAdjacentAd(el)) return;
+    if (findWrap(kindClass, 1)) { state.heroDoneForPage = true; return; }
+
+    const id = pickIdFromAll(allIds, cursorKey);
+    if (!id) return;
+
+    const wrap = insertAfter(el, id, kindClass, 1);
+    if (!wrap) return;
+
+    state.heroDoneForPage = true;
+    observePlaceholder(id);
+    enqueueShow(id);
+    drainQueue(); // FIX: was calling undefined startShowQueue()
+  }
+
+  // ─── Scheduler ──────────────────────────────────────────────────────────────
+  function scheduleRun(delayMs, 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) {}
+      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 || isBlocked() || now() > state.burstDeadline || state.burstCount >= 8) {
+        state.burstActive = false; return;
+      }
+      state.burstCount++;
+      scheduleRun(0, (inserted) => {
+        if (!inserted && !state.pending.length) { state.burstActive = false; return; }
+        setTimeout(step, inserted > 0 ? 120 : 220);
+      });
+    };
+    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;
+    // Observers are intentionally kept alive across ajaxify cycles.
+  }
+
+  function shouldReactToMutations(mutations) {
+    for (const m of mutations) {
+      if (!m.addedNodes || !m.addedNodes.length) continue;
+      for (const n of m.addedNodes) {
+        if (!n || n.nodeType !== 1) continue;
+        const el = n;
+        if (
+          (el.matches && (
+            el.matches(SELECTORS.postItem) ||
+            el.matches(SELECTORS.topicItem) ||
+            el.matches(SELECTORS.categoryItem)
+          )) ||
+          (el.querySelector && (
+            el.querySelector(SELECTORS.postItem) ||
+            el.querySelector(SELECTORS.topicItem) ||
+            el.querySelector(SELECTORS.categoryItem)
+          ))
+        ) return true;
+      }
+    }
+    return false;
+  }
+
+  function ensureDomObserver() {
+    if (state.domObs) return;
+    state.domObs = new MutationObserver((mutations) => {
+      if (state.internalDomChange > 0 || isBlocked()) return;
+      if (!shouldReactToMutations(mutations)) return;
+      requestBurst();
+    });
+    try { state.domObs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
+  }
+
+  // ─── NodeBB / scroll bindings ────────────────────────────────────────────────
+  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(); initPileFixObserver();
+      insertHeroAdEarly().catch(() => {});
+      requestBurst();
+      setTimeout(schedulePileFix, 80);
+      setTimeout(schedulePileFix, 500);
+    });
+    $(window).on('action:ajaxify.contentLoaded.ezoicInfinite', () => {
+      if (!isBlocked()) requestBurst();
+    });
+    $(window).on([
+      'action:posts.loaded', 'action:topics.loaded', 'action:categories.loaded',
+      'action:category.loaded', 'action:topic.loaded', 'action:infiniteScroll.loaded',
+    ].map((e) => e + '.ezoicInfinite').join(' '), () => {
+      if (!isBlocked()) {
+        requestBurst();
+        setTimeout(schedulePileFix, 80);
+        setTimeout(schedulePileFix, 500);
+      }
+    });
+    try {
+      require(['hooks'], (hooks) => {
+        if (!hooks || typeof hooks.on !== 'function') return;
+        ['action:ajaxify.end','action:ajaxify.contentLoaded','action:posts.loaded',
+         'action:topics.loaded','action:categories.loaded','action:category.loaded',
+         'action:topic.loaded','action:infiniteScroll.loaded'].forEach((ev) => {
+          try { hooks.on(ev, () => { if (!isBlocked()) requestBurst(); }); } catch (e) {}
+        });
+      });
+    } catch (e) {}
+  }
+
+  function bindScroll() {
+    let ticking = false;
+    window.addEventListener('scroll', () => {
+      try {
+        const t = now(), y = window.scrollY || window.pageYOffset || 0;
+        if (state.lastScrollTs) {
+          const dt = t - state.lastScrollTs;
+          const dy = Math.abs(y - (state.lastScrollY || 0));
+          if (dt > 0 && dy / dt >= BOOST_SPEED_PX_PER_MS) {
+            const wasBoosted = isBoosted();
+            state.scrollBoostUntil = Math.max(state.scrollBoostUntil || 0, t + BOOST_DURATION_MS);
+            if (!wasBoosted) ensurePreloadObserver();
+          }
+        }
+        state.lastScrollY = y; state.lastScrollTs = t;
+      } catch (e) {}
+      if (ticking) return;
+      ticking = true;
+      requestAnimationFrame(() => { ticking = false; requestBurst(); });
+    }, { passive: true });
+  }
+
+  // ─── Boot ────────────────────────────────────────────────────────────────────
+  state.pageKey = getPageKey();
+  muteNoisyConsole(); ensureTcfApiLocator(); warmUpNetwork(); patchShowAds();
+  ensurePreloadObserver(); ensureDomObserver(); initPileFixObserver();
+  bindNodeBB(); bindScroll();
+  blockedUntil = 0;
+  insertHeroAdEarly().catch(() => {});
+  requestBurst();
+  schedulePileFix();
+
+})();

package/public/style.css

@@ -1,28 +1,88 @@
-/* Conteneur de pub */
+/*
+  Keep our NodeBB-inserted wrappers CLS-safe.
+  NOTE: must not rely on `.ezoic-ad` because Ezoic uses that class internally.
+*/
 .nodebb-ezoic-wrap {
+  display: block;
+  width: 100%;
+  margin: 0 !important;
+  padding: 0 !important;
+  overflow: hidden;
+}
+
+.nodebb-ezoic-wrap > [id^="ezoic-pub-ad-placeholder-"] {
+  margin: 0 !important;
+  padding: 0 !important;
+  /* Keep the placeholder measurable (IO) but visually negligible */
+  min-height: 1px;
+}
+
+/* If Ezoic wraps inside our wrapper, keep it tight */
+.nodebb-ezoic-wrap span.ezoic-ad,
+.nodebb-ezoic-wrap .ezoic-ad {
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+/* Remove the classic "gap under iframe" (baseline/inline-block) */
+.nodebb-ezoic-wrap,
+.nodebb-ezoic-wrap * {
+  line-height: 0 !important;
+  font-size: 0 !important;
+}
+
+.nodebb-ezoic-wrap iframe,
+.nodebb-ezoic-wrap div[id$="__container__"] iframe {
   display: block !important;
-  width: 100% !important;
-  clear: both !important;
-  margin: 25px 0 !important;
-  min-height: 100px; /* Crucial pour que Ezoic détecte l'emplacement */
-  text-align: center;
+  vertical-align: top !important;
 }
 
-/* Fix spécifique pour le premier sujet */
-.nodebb-ezoic-wrap[data-ezoic-pinned="true"] {
-  min-height: 150px;
-  border-bottom: 1px solid rgba(0,0,0,0.05);
-  margin-top: 0 !important;
+.nodebb-ezoic-wrap div[id$="__container__"] {
+  display: block !important;
+  line-height: 0 !important;
 }
 
-/* Cache les blocs vides pour éviter les trous blancs */
-.nodebb-ezoic-wrap:empty {
-  height: 0 !important;
-  min-height: 0 !important;
+
+/* Collapse empty ad blocks (prevents "holes" when an ad doesn't fill or gets destroyed) */
+.nodebb-ezoic-wrap.is-empty {
+  display: block !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  /* Don't fully collapse (can prevent fill / triggers "unused"), keep it at 1px */
+  height: 1px !important;
+  min-height: 1px !important;
+  overflow: hidden !important;
+}
+
+/*
+  Optional: also neutralize spacing on native Ezoic `.ezoic-ad` blocks.
+  (Keeps your previous "CSS very good" behavior.)
+*/
+.ezoic-ad {
   margin: 0 !important;
+  padding: 0 !important;
+}
+/* Remove Ezoic's large reserved min-height inside our wrappers (topics/messages) */
+.nodebb-ezoic-wrap .ezoic-ad,
+.nodebb-ezoic-wrap span.ezoic-ad {
+  min-height: 1px !important; /* kill 400px gaps */
+  height: auto !important;
 }
 
-/* Évite que les pubs "volent" au scroll */
+/* Ensure Ezoic reportline doesn't affect layout */
+.nodebb-ezoic-wrap .reportline{position:absolute!important;}
+
+/* Ezoic sometimes injects `position: sticky` inside placements. In long NodeBB topics,
+   this can create "gliding" and sudden disappear/reappear effects while scrolling.
+   We neutralize sticky positioning *inside our injected wrappers* only. */
 .nodebb-ezoic-wrap .ezads-sticky-intradiv {
   position: static !important;
-}
+  top: auto !important;
+}
+
+
+/* ===== V17 host styling ===== */
+li.nodebb-ezoic-host { list-style: none; width: 100%; display: block; }
+li.nodebb-ezoic-host > .nodebb-ezoic-wrap.ezoic-ad-between { width: 100%; display: block; }
+/* ===== /V17 ===== */
+

package/public/test.txt

@@ -0,0 +1 @@
+hi