nodebb-plugin-ezoic-infinite 1.5.8 → 1.5.9

package/library.js

@@ -68,7 +68,7 @@ async function getSettings() {
 async function isUserExcluded(uid, excludedGroups) {
   if (!uid || !excludedGroups.length) return false;
   const userGroups = await groups.getUserGroups([uid]);
-  return (userGroups[0] || []).some(g => excludedGroups.includes((g && g.name) ? g.name : g));
+  return (userGroups[0] || []).some(g => excludedGroups.includes((g && g.name) ? g.name : String(g)));
 }
 
 plugin.onSettingsSet = function (data) {
@@ -105,13 +105,13 @@ plugin.init = async ({ router, middleware }) => {
   router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, render);
   router.get('/api/admin/plugins/ezoic-infinite', render);
 
-  router.get('/api/plugins/ezoic-infinite/config', middleware.authenticate, async (req, res) => {
+  router.get('/api/plugins/ezoic-infinite/config', async (req, res) => {
     const settings = await getSettings();
-    const uid = (typeof req.uid === 'number' ? req.uid : (req.user && typeof req.user.uid === 'number' ? req.user.uid : 0));
-    const excluded = await isUserExcluded(uid, settings.excludedGroups);
+    const excluded = await isUserExcluded((req.uid || (req.user && req.user.uid)), settings.excludedGroups);
 
     res.json({
       excluded,
+      excludedGroups: settings.excludedGroups,
       enableBetweenAds: settings.enableBetweenAds,
       showFirstTopicAd: settings.showFirstTopicAd,
       placeholderIds: settings.placeholderIds,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.5.8",
+  "version": "1.5.9",
   "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",

package/public/client.js

@@ -1,609 +1,367 @@
-(function () {
-  'use strict';
-
-  // Safety stubs (do NOT stub showAds)
-  window._ezaq = window._ezaq || [];
-  window.ezstandalone = window.ezstandalone || {};
-  window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-
-  // NodeBB client context
-  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
-
-  const WRAP_CLASS = 'ezoic-ad';
-  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
-
-  // Insert at most N ads per run to keep the UI smooth on infinite scroll
-  const MAX_INSERTS_PER_RUN = 3;
-
-  // Preload before viewport (tune if you want even earlier)
-  const PRELOAD_ROOT_MARGIN = '1200px 0px';
-
-  const SELECTORS = {
-    topicItem: 'li[component="category/topic"]',
-    postItem: '[component="post"][data-pid]',
-    categoryItem: 'li[component="categories/category"]',
-  };
-
-  // Hard block during navigation to avoid “placeholder does not exist” spam
-  let EZOIC_BLOCKED = false;
-
-  const state = {
-    pageKey: null,
-    cfg: null,
-
-    poolTopics: [],
-    poolPosts: [],
-    poolCategories: [],
-
-    usedTopics: new Set(),
-    usedPosts: new Set(),
-    usedCategories: new Set(),
-
-    // throttle per placeholder id
-    lastShowById: new Map(),
-
-    // observers / schedulers
-    domObs: null,
-    io: null,
-    runQueued: false,
-
-    // hero
-    heroDoneForPage: false,
-  };
-
-  const sessionDefinedIds = new Set();
-  const insertingIds = new Set();
+'use strict';
 
-  // ---------- small utils ----------
+/**
+ * Ezoic Infinite Ads for NodeBB 4.x
+ * - Event-driven only (ajaxify hooks + MutationObserver + IntersectionObserver)
+ * - Hard gate on server config (respects excluded groups BEFORE any injection)
+ * - Placeholder Registry: keeps all placeholder elements alive in a hidden pool so ez-standalone never complains
+ * - Safe showAds wrapper (array, varargs, single) + tokenized execution across ajaxify navigations
+ */
 
-  function normalizeBool(v) {
-    return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
+(function () {
+  const CFG_URL = '/api/plugins/ezoic-infinite/config';
+
+  // -------------------------
+  // Utilities
+  // -------------------------
+  const now = () => (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
+  const clamp = (n, a, b) => Math.max(a, Math.min(b, n));
+
+  function on(ev, fn) { document.addEventListener(ev, fn); }
+  function once(ev, fn) {
+    const h = (e) => { document.removeEventListener(ev, h); fn(e); };
+    document.addEventListener(ev, h);
   }
 
-  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);
+  // -------------------------
+  // Global state / navigation token
+  // -------------------------
+  let navToken = 0; // increment on ajaxify.start (page is about to be replaced)
+  let rafScheduled = false;
+
+  // resolved config (or null if failed)
+  let cfgPromise = null;
+  let cfg = null;
+
+  // -------------------------
+  // Placeholder Registry (keeps IDs alive)
+  // -------------------------
+  const Pool = {
+    el: null,
+    ensurePool() {
+      if (this.el && document.body.contains(this.el)) return this.el;
+      const d = document.createElement('div');
+      d.id = 'ezoic-placeholder-pool';
+      d.style.display = 'none';
+      d.setAttribute('aria-hidden', 'true');
+      document.body.appendChild(d);
+      this.el = d;
+      return d;
+    },
+    ensurePlaceholder(id) {
+      if (!id) return null;
+      let ph = document.getElementById(id);
+      if (ph) return ph;
+      const pool = this.ensurePool();
+      ph = document.createElement('div');
+      ph.id = id;
+      pool.appendChild(ph);
+      return ph;
+    },
+    returnToPool(id) {
+      const ph = document.getElementById(id);
+      if (!ph) return;
+      const pool = this.ensurePool();
+      if (ph.parentElement !== pool) {
+        pool.appendChild(ph);
       }
     }
-    return out;
-  }
-
-  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 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';
-
-    // fallback by DOM
-    if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
-    if (document.querySelector(SELECTORS.postItem)) return 'topic';
-    if (document.querySelector(SELECTORS.topicItem)) return 'categoryTopics';
-    return 'other';
-  }
+  };
 
-  function getTopicItems() {
-    return Array.from(document.querySelectorAll(SELECTORS.topicItem));
+  // -------------------------
+  // Ezoic showAds safe wrapper (installed even if defined later)
+  // -------------------------
+  function normalizeIds(argsLike) {
+    const args = Array.from(argsLike);
+    if (!args.length) return [];
+    // showAds([id1,id2]) or showAds([[...]]) edge
+    if (args.length === 1 && Array.isArray(args[0])) return args[0].flat().map(String);
+    return args.flat().map(String);
   }
 
-  function getCategoryItems() {
-    return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
-  }
+  function wrapShowAds(original) {
+    if (!original || original.__nodebbSafeWrapped) return original;
 
-  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;
-    });
-  }
+    const wrapped = function (...args) {
+      const ids = normalizeIds(args);
+      if (!ids.length) return;
 
-  // ---------- warm-up & patching ----------
-
-  const _warmLinksDone = new Set();
-  function warmUpNetwork() {
-    try {
-      const head = document.head || document.getElementsByTagName('head')[0];
-      if (!head) return;
-      const links = [
-        ['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],
-      ];
-      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) {}
-  }
+      for (const id of ids) {
+        // Ensure placeholder exists somewhere (pool), so ez-standalone won't log "does not exist"
+        Pool.ensurePlaceholder(id);
 
-  // Patch showAds to avoid warnings when a placeholder disappears (infinite scroll, ajaxify)
-  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 (EZOIC_BLOCKED) 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) {}
+        const el = document.getElementById(id);
+        if (el && document.body.contains(el)) {
+          try {
+            // Call one-by-one to avoid batch logging on missing nodes
+            original.call(window.ezstandalone, id);
+          } catch (e) {
+            // swallow: Ezoic can throw if called during transitions
           }
-        };
-      } catch (e) {}
+        }
+      }
     };
 
-    applyPatch();
-    if (!window.__nodebbEzoicPatched) {
-      try {
-        window.ezstandalone = window.ezstandalone || {};
-        window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-        window.ezstandalone.cmd.push(applyPatch);
-      } catch (e) {}
-    }
+    wrapped.__nodebbSafeWrapped = true;
+    return wrapped;
   }
 
-  // ---------- config & pools ----------
-
-  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 installShowAdsHook() {
+    // Minimal + Ezoic-safe:
+    // - ensure queues exist (prevents `_ezaq` / `cmd` undefined)
+    // - wrap showAds when it exists
+    // - ALSO queue a wrap inside ezstandalone.cmd for when Ezoic initializes later
+    window._ezaq = window._ezaq || [];
+    window.ezstandalone = window.ezstandalone || {};
+    window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+
+    if (window.ezstandalone.showAds) {
+      window.ezstandalone.showAds = wrapShowAds(window.ezstandalone.showAds);
     }
-  }
-
-  function initPools(cfg) {
-    if (!cfg) return;
-    if (state.poolTopics.length === 0) state.poolTopics = parsePool(cfg.placeholderIds);
-    if (state.poolPosts.length === 0) state.poolPosts = parsePool(cfg.messagePlaceholderIds);
-    if (state.poolCategories.length === 0) state.poolCategories = parsePool(cfg.categoryPlaceholderIds);
-  }
-
-  // ---------- insertion primitives ----------
 
-  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;
+    // When standalone finishes loading, it will run cmd queue — wrap then too.
+    window.ezstandalone.cmd.push(function () {
+      if (window.ezstandalone && window.ezstandalone.showAds) {
+        window.ezstandalone.showAds = wrapShowAds(window.ezstandalone.showAds);
+      }
+    });
   }
 
-  function buildWrap(target, id, kindClass, afterPos) {
-    const tag = (target && target.tagName === 'LI') ? 'li' : 'div';
-    const wrap = document.createElement(tag);
-    if (tag === 'li') {
-      wrap.style.listStyle = 'none';
-      // preserve common NodeBB list styling
-      if (target && target.classList && target.classList.contains('list-group-item')) wrap.classList.add('list-group-item');
-    }
-    wrap.className = `${WRAP_CLASS} ${kindClass}`;
-    if (wrap.tagName === 'LI') {
-      wrap.setAttribute('role', 'presentation');
-      wrap.setAttribute('aria-hidden', 'true');
-    }
-    wrap.setAttribute('data-ezoic-after', String(afterPos));
-    wrap.style.width = '100%';
-
-    const ph = document.createElement('div');
-    ph.id = `${PLACEHOLDER_PREFIX}${id}`;
-    ph.setAttribute('data-ezoic-id', String(id));
-    wrap.appendChild(ph);
-
-    return wrap;
+  function ezCmd(fn) {
+    // Tokenize so queued callbacks don't run after navigation
+    const tokenAtSchedule = navToken;
+    window.ezstandalone = window.ezstandalone || {};
+    window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+    window.ezstandalone.cmd.push(function () {
+      if (tokenAtSchedule !== navToken) return;
+      try { fn(); } catch (e) {}
+    });
   }
 
-  function findWrap(kindClass, afterPos) {
-    return document.querySelector(`.${WRAP_CLASS}.${kindClass}[data-ezoic-after="${afterPos}"]`);
-  }
+  // -------------------------
+  // Config (hard gate)
+  // -------------------------
+  function prefetchConfig() {
+    if (cfgPromise) return cfgPromise;
+
+    cfgPromise = fetch(CFG_URL, { credentials: 'same-origin' })
+      .then(r => r.ok ? r.json() : Promise.reject(new Error('config http ' + r.status)))
+      .then(data => {
+        cfg = data;
+        // Pre-create placeholders in pool so Ezoic never complains even before first injection
+        const ids = parsePlaceholderIds((cfg && cfg.placeholderIds) || '');
+        ids.forEach(id => Pool.ensurePlaceholder(id));
+        return cfg;
+      })
+      .catch(() => {
+        cfg = null;
+        return null;
+      });
 
-  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}`);
-    if (existingPh && existingPh.isConnected) return null;
-
-    insertingIds.add(id);
-    try {
-      const wrap = buildWrap(target, id, kindClass, afterPos);
-      target.insertAdjacentElement('afterend', wrap);
-      return wrap;
-    } finally {
-      insertingIds.delete(id);
-    }
+    return cfgPromise;
   }
 
-  function pickId(pool) {
-    return pool.length ? pool.shift() : null;
+  function parsePlaceholderIds(s) {
+    return String(s || '')
+      .split(',')
+      .map(x => x.trim())
+      .filter(Boolean);
   }
 
-  function showAd(id) {
-    if (!id || EZOIC_BLOCKED) return;
-
-    const now = Date.now();
-    const last = state.lastShowById.get(id) || 0;
-    if (now - last < 1500) return; // basic throttle
-
-    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-    if (!ph || !ph.isConnected) return;
-
-    state.lastShowById.set(id, now);
+  // -------------------------
+  // Ad insertion logic
+  // -------------------------
+  const Ad = {
+    // throttle showAds per placeholder id
+    lastShowAt: new Map(),
+    minShowIntervalMs: 1500,
 
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      const ez = window.ezstandalone;
-
-      // Fast path
-      if (typeof ez.showAds === 'function') {
-        ez.showAds(id);
-        sessionDefinedIds.add(id);
-        return;
+    // Observers
+    io: null,
+    mo: null,
+
+    // Bookkeeping
+    insertedKeys: new Set(), // avoid duplicate injection on re-renders
+
+    initObservers() {
+      if (!this.io) {
+        this.io = new IntersectionObserver((entries) => {
+          for (const e of entries) {
+            if (!e.isIntersecting) continue;
+            const id = e.target && e.target.getAttribute('data-ezoic-id');
+            if (id) this.requestShow(id);
+          }
+        }, { root: null, rootMargin: '1200px 0px', threshold: 0.01 });
       }
 
-      // Queue once for when Ezoic is ready
-      ez.cmd = ez.cmd || [];
-      if (!ph.__ezoicQueued) {
-        ph.__ezoicQueued = true;
-        ez.cmd.push(() => {
-          try {
-            if (EZOIC_BLOCKED) return;
-            const el = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-            if (!el || !el.isConnected) return;
-            window.ezstandalone.showAds(id);
-            sessionDefinedIds.add(id);
-          } catch (e) {}
-        });
+      if (!this.mo) {
+        this.mo = new MutationObserver(() => this.scheduleScan());
+        const root = document.querySelector('#content, #panel, main, body');
+        if (root) this.mo.observe(root, { childList: true, subtree: true });
       }
-    } catch (e) {}
-  }
-
-  // ---------- preload / above-the-fold ----------
+    },
+
+    disconnectObservers() {
+      try { this.io && this.io.disconnect(); } catch (e) {}
+      try { this.mo && this.mo.disconnect(); } catch (e) {}
+      this.io = null;
+      this.mo = null;
+    },
+
+    scheduleScan() {
+      if (rafScheduled) return;
+      rafScheduled = true;
+      requestAnimationFrame(() => {
+        rafScheduled = false;
+        this.scanAndInject();
+      });
+    },
 
-  function ensurePreloadObserver() {
-    if (state.io) return state.io;
-    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) {}
+    async scanAndInject() {
+      const c = await prefetchConfig();
+      if (!c) return;
 
-          const idAttr = el && el.getAttribute && el.getAttribute('data-ezoic-id');
-          const id = parseInt(idAttr, 10);
-          if (Number.isFinite(id) && id > 0) showAd(id);
-        }
-      }, { root: null, rootMargin: PRELOAD_ROOT_MARGIN, threshold: 0.01 });
-    } catch (e) {
-      state.io = null;
-    }
-    return state.io;
-  }
+      if (c.excluded) return; // HARD stop: never inject for excluded users
 
-  function observePlaceholder(id) {
-    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-    if (!ph || !ph.isConnected) return;
-    const io = ensurePreloadObserver();
-    try { io && io.observe(ph); } catch (e) {}
-
-    // If already above fold, fire immediately
-    try {
-      const r = ph.getBoundingClientRect();
-      if (r.top < window.innerHeight * 1.5 && r.bottom > -200) showAd(id);
-    } catch (e) {}
-  }
-
-  // ---------- insertion logic ----------
+      installShowAdsHook();
+      this.initObservers();
 
-  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);
-  }
+      if (c.enableBetweenAds) this.injectBetweenTopics(c);
+      // Extend: categories ads if you use them
+    },
 
-  function injectBetween(kindClass, items, interval, showFirst, pool, usedSet) {
-    if (!items.length) return 0;
+    // NodeBB topic list injection (between li rows)
+    injectBetweenTopics(c) {
+      const container =
+        document.querySelector('.category .topic-list') ||
+        document.querySelector('.topics .topic-list') ||
+        document.querySelector('.topic-list');
 
-    const targets = computeTargets(items.length, interval, showFirst);
-    let inserted = 0;
+      if (!container) return;
 
-    for (const afterPos of targets) {
-      if (inserted >= MAX_INSERTS_PER_RUN) break;
+      const rows = Array.from(container.querySelectorAll('li, .topic-row, .topic-item'));
+      if (!rows.length) return;
 
-      const el = items[afterPos - 1];
-      if (!el || !el.isConnected) continue;
-      if (isAdjacentAd(el)) continue;
-      if (findWrap(kindClass, afterPos)) continue;
+      const ids = parsePlaceholderIds(c.placeholderIds);
+      if (!ids.length) return;
 
-      const id = pickId(pool);
-      if (!id) break;
+      const interval = clamp(parseInt(c.intervalPosts, 10) || 6, 1, 50);
 
-      usedSet.add(id);
-      const wrap = insertAfter(el, id, kindClass, afterPos);
-      if (!wrap) {
-        usedSet.delete(id);
-        pool.unshift(id);
-        continue;
+      // HERO: early, above-the-fold (first eligible insertion point)
+      if (c.showFirstTopicAd) {
+        this.insertAdAfterRow(rows[0], ids[0], 'hero-topic-0');
       }
 
-      observePlaceholder(id);
-      inserted += 1;
-    }
-
-    return inserted;
-  }
-
-  async function insertHeroAdEarly() {
-    if (state.heroDoneForPage) return;
-    const cfg = await fetchConfigOnce();
-    if (!cfg || cfg.excluded) return;
-
-    initPools(cfg);
-
-    const kind = getKind();
-    let items = [];
-    let pool = null;
-    let usedSet = null;
-    let kindClass = '';
-
-    if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
-      items = getPostContainers();
-      pool = state.poolPosts;
-      usedSet = state.usedPosts;
-      kindClass = 'ezoic-ad-message';
-    } else if (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
-      items = getTopicItems();
-      pool = state.poolTopics;
-      usedSet = state.usedTopics;
-      kindClass = 'ezoic-ad-between';
-    } else if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
-      items = getCategoryItems();
-      pool = state.poolCategories;
-      usedSet = state.usedCategories;
-      kindClass = 'ezoic-ad-categories';
-    } else {
-      return;
-    }
-
-    if (!items.length) return;
-
-    // Insert after the very first item (above-the-fold)
-    const afterPos = 1;
-    const el = items[afterPos - 1];
-    if (!el || !el.isConnected) return;
-    if (isAdjacentAd(el)) return;
-    if (findWrap(kindClass, afterPos)) { state.heroDoneForPage = true; return; }
+      // Between rows
+      let idIndex = 0;
+      for (let i = interval; i < rows.length; i += interval) {
+        idIndex = (idIndex + 1) % ids.length;
+        this.insertAdAfterRow(rows[i - 1], ids[idIndex], `between-topic-${i}`);
+      }
+    },
 
-    const id = pickId(pool);
-    if (!id) return;
+    insertAdAfterRow(rowEl, placeholderId, key) {
+      if (!rowEl || !placeholderId || !key) return;
+      if (this.insertedKeys.has(key)) return;
 
-    usedSet.add(id);
-    const wrap = insertAfter(el, id, kindClass, afterPos);
-    if (!wrap) {
-      usedSet.delete(id);
-      pool.unshift(id);
-      return;
-    }
+      // If already present nearby, skip
+      if (rowEl.nextElementSibling && rowEl.nextElementSibling.classList && rowEl.nextElementSibling.classList.contains('ezoic-ad-wrapper')) {
+        this.insertedKeys.add(key);
+        return;
+      }
 
-    state.heroDoneForPage = true;
-    observePlaceholder(id);
-  }
+      const isLi = rowEl.tagName && rowEl.tagName.toLowerCase() === 'li';
+      const wrapper = document.createElement(isLi ? 'li' : 'div');
+      wrapper.className = 'ezoic-ad-wrapper';
+      wrapper.setAttribute('role', 'presentation');
+      wrapper.setAttribute('data-ezoic-id', placeholderId);
 
-  async function runCore() {
-    if (EZOIC_BLOCKED) return;
+      // Theme compatibility: if list uses list-group-item, keep it to avoid layout/JS breaks
+      if (isLi && rowEl.classList.contains('list-group-item')) {
+        wrapper.classList.add('list-group-item');
+      }
 
-    patchShowAds();
+      // Ensure placeholder exists (in pool) then move it into wrapper
+      const ph = Pool.ensurePlaceholder(placeholderId);
+      // If placeholder is currently rendered elsewhere, move it (Ezoic uses id lookup)
+      try { wrapper.appendChild(ph); } catch (e) {}
 
-    const cfg = await fetchConfigOnce();
-    if (!cfg || cfg.excluded) return;
-    initPools(cfg);
+      // Insert into DOM
+      rowEl.insertAdjacentElement('afterend', wrapper);
+      this.insertedKeys.add(key);
 
-    const kind = getKind();
+      // Observe for preloading and request a show
+      if (this.io) this.io.observe(wrapper);
 
-    if (kind === 'topic') {
-      if (normalizeBool(cfg.enableMessageAds)) {
-        injectBetween(
-          'ezoic-ad-message',
-          getPostContainers(),
-          Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
-          normalizeBool(cfg.showFirstMessageAd),
-          state.poolPosts,
-          state.usedPosts
-        );
+      // If above fold, request immediately (no timeout)
+      const rect = wrapper.getBoundingClientRect();
+      if (rect.top < (window.innerHeight * 1.5)) {
+        this.requestShow(placeholderId);
       }
-    } else if (kind === 'categoryTopics') {
-      if (normalizeBool(cfg.enableBetweenAds)) {
-        injectBetween(
-          'ezoic-ad-between',
-          getTopicItems(),
-          Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
-          normalizeBool(cfg.showFirstTopicAd),
-          state.poolTopics,
-          state.usedTopics
-        );
+    },
+
+    requestShow(placeholderId) {
+      if (!placeholderId) return;
+
+      const last = this.lastShowAt.get(placeholderId) || 0;
+      const t = now();
+      if ((t - last) < this.minShowIntervalMs) return;
+      this.lastShowAt.set(placeholderId, t);
+
+      // Ensure placeholder exists in DOM (pool or wrapper)
+      Pool.ensurePlaceholder(placeholderId);
+
+      // Use ez cmd queue if available
+      const doShow = () => {
+        if (!window.ezstandalone || !window.ezstandalone.showAds) return;
+        // showAds is wrapped; calling with one id is safest
+        window.ezstandalone.showAds(placeholderId);
+      };
+
+      if (window.ezstandalone && Array.isArray(window.ezstandalone.cmd)) {
+        ezCmd(doShow);
+      } else {
+        doShow();
       }
-    } else if (kind === 'categories') {
-      if (normalizeBool(cfg.enableCategoryAds)) {
-        injectBetween(
-          'ezoic-ad-categories',
-          getCategoryItems(),
-          Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
-          normalizeBool(cfg.showFirstCategoryAd),
-          state.poolCategories,
-          state.usedCategories
-        );
-      }
-    }
-  }
-
-  function scheduleRun() {
-    if (state.runQueued) return;
-    state.runQueued = true;
-    window.requestAnimationFrame(() => {
-      state.runQueued = false;
-      const pk = getPageKey();
-      if (state.pageKey && pk !== state.pageKey) return;
-      runCore().catch(() => {});
-    });
-  }
-
-  // ---------- observers / lifecycle ----------
-
-  function cleanup() {
-    EZOIC_BLOCKED = true;
-
-    // remove all wrappers
-    try {
-      document.querySelectorAll(`.${WRAP_CLASS}`).forEach((el) => {
-        try { el.remove(); } catch (e) {}
+    },
+
+    // On navigation, return all placeholders to pool so they still exist
+    reclaimPlaceholders() {
+      const wrappers = document.querySelectorAll('.ezoic-ad-wrapper[data-ezoic-id]');
+      wrappers.forEach(w => {
+        const id = w.getAttribute('data-ezoic-id');
+        if (id) Pool.returnToPool(id);
       });
-    } catch (e) {}
-
-    // reset state
-    state.cfg = null;
-    state.poolTopics = [];
-    state.poolPosts = [];
-    state.poolCategories = [];
-    state.usedTopics.clear();
-    state.usedPosts.clear();
-    state.usedCategories.clear();
-    state.lastShowById.clear();
-    state.heroDoneForPage = false;
-
-    sessionDefinedIds.clear();
-
-    // keep observers alive (MutationObserver will re-trigger after navigation)
-  }
-
-  function ensureDomObserver() {
-    if (state.domObs) return;
-    state.domObs = new MutationObserver(() => {
-      if (!EZOIC_BLOCKED) scheduleRun();
-    });
-    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();
-      EZOIC_BLOCKED = false;
-
-      warmUpNetwork();
-      patchShowAds();
-      ensurePreloadObserver();
-      ensureDomObserver();
-
-      // Ultra-fast above-the-fold first
-      insertHeroAdEarly().catch(() => {});
-
-      // Then normal insertion
-      scheduleRun();
-    });
+      // Let NodeBB wipe DOM; we do not aggressively remove nodes here.
+      this.insertedKeys.clear();
+      this.lastShowAt.clear();
+    }
+  };
 
-    // Infinite scroll / partial updates
-    $(window).on('action:posts.loaded.ezoicInfinite action:topics.loaded.ezoicInfinite action:category.loaded.ezoicInfinite action:topic.loaded.ezoicInfinite', () => {
-      if (EZOIC_BLOCKED) return;
-      scheduleRun();
-    });
+  // -------------------------
+  // NodeBB hooks
+  // -------------------------
+  function onAjaxifyStart() {
+    navToken++;
+    Ad.disconnectObservers();
+    Ad.reclaimPlaceholders();
   }
 
-  function bindScroll() {
-    let ticking = false;
-    window.addEventListener('scroll', () => {
-      if (ticking) return;
-      ticking = true;
-      window.requestAnimationFrame(() => {
-        ticking = false;
-        if (!EZOIC_BLOCKED) scheduleRun();
-      });
-    }, { passive: true });
+  function onAjaxifyEnd() {
+    // Kick scan for new page
+    prefetchConfig();
+    Ad.scheduleScan();
   }
 
-  // ---------- boot ----------
-
-  state.pageKey = getPageKey();
-  warmUpNetwork();
-  patchShowAds();
-  ensurePreloadObserver();
-  ensureDomObserver();
+  // NodeBB exposes ajaxify events on document
+  on('ajaxify.start', onAjaxifyStart);
+  on('ajaxify.end', onAjaxifyEnd);
 
-  bindNodeBB();
-  bindScroll();
+  // First load
+  once('DOMContentLoaded', () => {
+    installShowAdsHook();
+    prefetchConfig();
+    Ad.scheduleScan();
+  });
 
-  // First paint: try hero + run
-  EZOIC_BLOCKED = false;
-  insertHeroAdEarly().catch(() => {});
-  scheduleRun();
 })();

package/public/style.css

@@ -1,21 +1,9 @@
-/* Keep Ezoic wrappers “CLS-safe” and remove the extra vertical spacing Ezoic often injects */
-.ezoic-ad {
-  display: block;
-  width: 100%;
-  margin: 0 !important;
-  padding: 0 !important;
-  overflow: hidden;
+.ezoic-ad,
+.ezoic-ad *,
+span.ezoic-ad,
+span[class*="ezoic"] {
+  min-height: 0 !important;
+  min-width: 0 !important;
 }
 
-.ezoic-ad > [id^="ezoic-pub-ad-placeholder-"] {
-  margin: 0 !important;
-  padding: 0 !important;
-  min-height: 1px; /* keeps placeholder measurable for IO */
-}
-
-/* Ezoic sometimes wraps in extra spans/divs with margins */
-.ezoic-ad span.ezoic-ad,
-.ezoic-ad .ezoic-ad {
-  margin: 0 !important;
-  padding: 0 !important;
-}
+.ezoic-ad-wrapper{margin:0;padding:0;list-style:none;}