nodebb-plugin-ezoic-infinite 1.5.7 → 1.5.8

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 : String(g)));
+  return (userGroups[0] || []).some(g => excludedGroups.includes((g && g.name) ? g.name : 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', async (req, res) => {
+  router.get('/api/plugins/ezoic-infinite/config', middleware.authenticate, async (req, res) => {
     const settings = await getSettings();
-    const excluded = await isUserExcluded(req.uid, settings.excludedGroups);
+    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);
 
     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.7",
+  "version": "1.5.8",
   "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",

package/public/client.js

@@ -1,50 +1,63 @@
 (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"]',
-    categoryItem: 'li[component="categories/category"]',
     postItem: '[component="post"][data-pid]',
-    postContent: '[component="post/content"]',
+    categoryItem: 'li[component="categories/category"]',
   };
 
-  // ----------------------------
-  // State
-  // ----------------------------
+  // Hard block during navigation to avoid “placeholder does not exist” spam
+  let EZOIC_BLOCKED = false;
+
   const state = {
     pageKey: null,
-    pageToken: 0,
-    cfgPromise: null,
     cfg: null,
-    // throttle per id
-    lastShowAt: new Map(),
-    // observed placeholders -> ids
+
+    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,
-    mo: null,
-    scheduled: false,
+    runQueued: false,
+
+    // hero
+    heroDoneForPage: false,
   };
 
-  // ----------------------------
-  // Small utils
-  // ----------------------------
-  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 || '';
-  }
+  const sessionDefinedIds = new Set();
+  const insertingIds = new Set();
+
+  // ---------- small utils ----------
 
   function normalizeBool(v) {
-    return v === true || v === 'true' || v === 1 || v === '1' || v === 'on' || v === 'yes';
+    return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
   function uniqInts(lines) {
@@ -62,7 +75,22 @@
 
   function parsePool(raw) {
     if (!raw) return [];
-    return uniqInts(String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean));
+    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() {
@@ -70,6 +98,7 @@
     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';
@@ -89,130 +118,135 @@
     const nodes = Array.from(document.querySelectorAll(SELECTORS.postItem));
     return nodes.filter((el) => {
       if (!el || !el.isConnected) return false;
-      if (!el.querySelector(SELECTORS.postContent)) return false;
-      const parentPost = el.parentElement && el.parentElement.closest(SELECTORS.postItem);
+      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 isPlaceholderPresent(id) {
-    const el = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-    return !!(el && el.isConnected);
-  }
+  // ---------- warm-up & patching ----------
 
-  function schedule(fn) {
-    if (state.scheduled) return;
-    state.scheduled = true;
-    requestAnimationFrame(() => {
-      state.scheduled = false;
-      try { fn(); } catch (e) {}
-    });
-  }
-
-  // ----------------------------
-  // Ezoic showAds patch (handles arrays, varargs, and filters absent placeholders)
-  // ----------------------------
-  function patchShowAds() {
+  const _warmLinksDone = new Set();
+  function warmUpNetwork() {
     try {
-      window.ezstandalone = window.ezstandalone || {};
-      const ez = window.ezstandalone;
-      if (ez.__nodebbEzoicPatched) return;
-
-      // If showAds isn't ready yet, patch when it appears via cmd (no polling)
-      const apply = () => {
-        try {
-          if (!window.ezstandalone || typeof window.ezstandalone.showAds !== 'function') return;
-          const ez2 = window.ezstandalone;
-          if (ez2.__nodebbEzoicPatched) return;
-
-          const orig = ez2.showAds;
-          ez2.showAds = function () {
-            // Normalize ids from:
-            // - showAds([1,2])
-            // - showAds(1,2,3)
-            // - showAds(1)
-            const ids = [];
-            if (arguments.length === 1 && Array.isArray(arguments[0])) {
-              for (const v of arguments[0]) ids.push(v);
-            } else {
-              for (let i = 0; i < arguments.length; i++) ids.push(arguments[i]);
-            }
-
-            const seen = new Set();
-            for (const v of ids) {
-              const id = parseInt(v, 10);
-              if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-              if (!isPlaceholderPresent(id)) continue;
-              seen.add(id);
-              try { orig.call(ez2, id); } catch (e) {}
-            }
-          };
-
-          ez2.__nodebbEzoicPatched = true;
-        } catch (e) {}
-      };
-
-      apply();
-      if (!window.ezstandalone.__nodebbEzoicPatchQueued) {
-        window.ezstandalone.__nodebbEzoicPatchQueued = true;
-        ez.cmd = ez.cmd || [];
-        ez.cmd.push(apply);
+      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) {}
   }
 
-  function safeCmd(token, fn) {
+  // 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) {}
+          }
+        };
+      } 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 & pools ----------
+
+  async function fetchConfigOnce() {
+    if (state.cfg) return state.cfg;
     try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      window.ezstandalone.cmd.push(function () {
-        // Drop stale work after ajaxify navigation
-        if (token !== state.pageToken) return;
-        if (getPageKey() !== state.pageKey) return;
-        try { fn(); } catch (e) {}
-      });
-    } catch (e) {}
+      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 showAd(id) {
-    if (!id) return;
-    // throttle to avoid repeated calls during rerenders
-    const now = Date.now();
-    const last = state.lastShowAt.get(id) || 0;
-    if (now - last < 1500) return;
-    state.lastShowAt.set(id, now);
+  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);
+  }
 
-    const token = state.pageToken;
-    safeCmd(token, () => {
-      if (!isPlaceholderPresent(id)) return;
-      patchShowAds();
-      if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') {
-        window.ezstandalone.showAds(id);
-      }
-    });
+  // ---------- 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;
   }
 
-  // ----------------------------
-  // DOM insertion (HTML-valid: if target is <li>, wrapper is <li>)
-  // ----------------------------
-  function buildWrap(id, kindClass, afterPos, liLike) {
-    const wrap = document.createElement(liLike ? 'li' : 'div');
+  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.setAttribute('role', 'presentation');
     wrap.style.width = '100%';
 
-    // Keep list styling if we're inside list-group
-    if (liLike && !wrap.classList.contains('list-group-item')) {
-      const targetIsListGroup = wrap.parentElement && wrap.parentElement.classList && wrap.parentElement.classList.contains('list-group');
-      // can't detect parent yet; we'll keep it minimal
-    }
-
     const ph = document.createElement('div');
     ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+    ph.setAttribute('data-ezoic-id', String(id));
     wrap.appendChild(ph);
+
     return wrap;
   }
 
@@ -223,255 +257,353 @@
   function insertAfter(target, id, kindClass, afterPos) {
     if (!target || !target.insertAdjacentElement) return null;
     if (findWrap(kindClass, afterPos)) return null;
+    if (insertingIds.has(id)) return null;
 
-    // avoid duplicates if already exists
-    if (isPlaceholderPresent(id)) return null;
-
-    const liLike = String(target.tagName).toUpperCase() === 'LI';
-    const wrap = buildWrap(id, kindClass, afterPos, liLike);
+    const existingPh = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+    if (existingPh && existingPh.isConnected) return null;
 
-    // If list-group-item exists on target, mirror it to keep theme markup consistent
-    if (liLike && target.classList && target.classList.contains('list-group-item')) {
-      wrap.classList.add('list-group-item');
+    insertingIds.add(id);
+    try {
+      const wrap = buildWrap(target, id, kindClass, afterPos);
+      target.insertAdjacentElement('afterend', wrap);
+      return wrap;
+    } finally {
+      insertingIds.delete(id);
     }
-
-    target.insertAdjacentElement('afterend', wrap);
-    return wrap;
   }
 
-  // ----------------------------
-  // Observers: preload + rerun on NodeBB DOM changes
-  // ----------------------------
-  function ensureIO() {
-    if (state.io) return;
-    if (!('IntersectionObserver' in window)) return;
-
-    state.io = new IntersectionObserver((entries) => {
-      for (const e of entries) {
-        if (!e.isIntersecting) continue;
-        const ph = e.target;
-        const id = parseInt(String(ph.id).replace(PLACEHOLDER_PREFIX, ''), 10);
-        if (Number.isFinite(id)) showAd(id);
-        try { state.io.unobserve(ph); } catch (err) {}
-      }
-    }, { root: null, rootMargin: '1200px 0px', threshold: 0 });
+  function pickId(pool) {
+    return pool.length ? pool.shift() : null;
   }
 
-  function observePlaceholder(id) {
-    ensureIO();
-    if (!state.io) return;
+  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) return;
-    try { state.io.observe(ph); } catch (e) {}
-  }
+    if (!ph || !ph.isConnected) return;
 
-  function ensureMO() {
-    if (state.mo) return;
-    state.mo = new MutationObserver(() => schedule(runCore));
-    try { state.mo.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
-  }
+    state.lastShowById.set(id, now);
 
-  // ----------------------------
-  // Config / exclusion
-  // ----------------------------
-  async function fetchConfig() {
-    if (state.cfg) return state.cfg;
-    if (state.cfgPromise) return state.cfgPromise;
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      const ez = window.ezstandalone;
 
-    state.cfgPromise = (async () => {
-      try {
-        const res = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
-        if (!res.ok) return null;
-        const cfg = await res.json();
-        state.cfg = cfg;
-        return cfg;
-      } catch (e) {
-        return null;
-      } finally {
-        state.cfgPromise = null;
+      // Fast path
+      if (typeof ez.showAds === 'function') {
+        ez.showAds(id);
+        sessionDefinedIds.add(id);
+        return;
       }
-    })();
 
-    return state.cfgPromise;
-  }
-
-  function getUserGroupNamesFromAjaxify() {
-    try {
-      const ax = window.ajaxify;
-      const u = ax && ax.data && (ax.data.user || ax.data.profile || null);
-      if (!u) return [];
-      // NodeBB varies by route/theme; handle multiple shapes
-      const groupsA = u.groups || u.group_names || u.groupNames;
-      if (Array.isArray(groupsA)) return groupsA.map(g => (g && g.name) ? g.name : String(g)).filter(Boolean);
-      if (typeof groupsA === 'string') return groupsA.split(',').map(s => s.trim()).filter(Boolean);
+      // 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) {}
+        });
+      }
     } catch (e) {}
-    return [];
   }
 
-  function parseExcludedGroupsFromCfg(cfg) {
-    const v = cfg && (cfg.excludedGroups || cfg.excludedGroupNames || cfg.excluded_groups);
-    if (!v) return [];
-    if (Array.isArray(v)) return v.map(x => (x && x.name) ? x.name : String(x)).filter(Boolean);
-    return String(v).split(',').map(s => s.trim()).filter(Boolean);
-  }
+  // ---------- preload / above-the-fold ----------
 
-  function isExcludedClientSide(cfg) {
-    // Prefer server decision if present
-    if (cfg && cfg.excluded === true) return true;
+  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) {}
+
+          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;
+  }
 
-    // Extra safety: if cfg contains excluded group names, cross-check client-side.
-    const excludedGroups = parseExcludedGroupsFromCfg(cfg);
-    if (!excludedGroups.length) return false;
-    const userGroups = getUserGroupNamesFromAjaxify();
-    if (!userGroups.length) return false;
+  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) {}
 
-    const set = new Set(userGroups);
-    return excludedGroups.some(g => set.has(g));
+    // 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) {}
   }
 
-  // ----------------------------
-  // Core injection
-  // ----------------------------
+  // ---------- insertion logic ----------
+
   function computeTargets(count, interval, showFirst) {
     const out = [];
     if (count <= 0) return out;
     if (showFirst) out.push(1);
-    for (let i = interval; i <= count; i += interval) out.push(i);
+    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 injectBetween(kindClass, items, interval, showFirst, pool) {
-    if (!items.length || !pool.length) return [];
+  function injectBetween(kindClass, items, interval, showFirst, pool, usedSet) {
+    if (!items.length) return 0;
 
     const targets = computeTargets(items.length, interval, showFirst);
-    const insertedIds = [];
+    let inserted = 0;
+
     for (const afterPos of targets) {
+      if (inserted >= MAX_INSERTS_PER_RUN) break;
+
       const el = items[afterPos - 1];
       if (!el || !el.isConnected) continue;
-      if (!pool.length) break;
+      if (isAdjacentAd(el)) continue;
       if (findWrap(kindClass, afterPos)) continue;
 
-      const id = pool.shift();
+      const id = pickId(pool);
+      if (!id) break;
+
+      usedSet.add(id);
       const wrap = insertAfter(el, id, kindClass, afterPos);
       if (!wrap) {
-        // push back if couldn't insert
+        usedSet.delete(id);
         pool.unshift(id);
         continue;
       }
 
-      insertedIds.push(id);
-
-      // Above-the-fold: immediate attempt
-      const rect = wrap.getBoundingClientRect ? wrap.getBoundingClientRect() : null;
-      const vh = window.innerHeight || 800;
-      if (rect && rect.top < (vh * 1.5)) {
-        showAd(id);
-      } else {
-        observePlaceholder(id);
-      }
+      observePlaceholder(id);
+      inserted += 1;
     }
-    return insertedIds;
-  }
 
-  function removeAllAds() {
-    try { document.querySelectorAll(`.${WRAP_CLASS}`).forEach(n => n.remove()); } catch (e) {}
+    return inserted;
   }
 
-  async function runCore() {
-    state.pageKey = getPageKey();
+  async function insertHeroAdEarly() {
+    if (state.heroDoneForPage) return;
+    const cfg = await fetchConfigOnce();
+    if (!cfg || cfg.excluded) return;
 
-    patchShowAds();
-
-    const cfg = await fetchConfig();
-    if (!cfg) return;
-
-    // If excluded: ensure we remove any previously injected wrappers
-    if (isExcludedClientSide(cfg)) {
-      removeAllAds();
-      return;
-    }
+    initPools(cfg);
 
     const kind = getKind();
+    let items = [];
+    let pool = null;
+    let usedSet = null;
+    let kindClass = '';
 
     if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
-      const pool = parsePool(cfg.messagePlaceholderIds);
-      injectBetween(
-        'ezoic-ad-message',
-        getPostContainers(),
-        Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
-        normalizeBool(cfg.showFirstMessageAd),
-        pool
-      );
+      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 (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
-      const pool = parsePool(cfg.placeholderIds);
-      injectBetween(
-        'ezoic-ad-between',
-        getTopicItems(),
-        Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
-        normalizeBool(cfg.showFirstTopicAd),
-        pool
-      );
+    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; }
+
+    const id = pickId(pool);
+    if (!id) return;
+
+    usedSet.add(id);
+    const wrap = insertAfter(el, id, kindClass, afterPos);
+    if (!wrap) {
+      usedSet.delete(id);
+      pool.unshift(id);
       return;
     }
 
-    if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
-      const pool = parsePool(cfg.categoryPlaceholderIds);
-      injectBetween(
-        'ezoic-ad-categories',
-        getCategoryItems(),
-        Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
-        normalizeBool(cfg.showFirstCategoryAd),
-        pool
-      );
+    state.heroDoneForPage = true;
+    observePlaceholder(id);
+  }
+
+  async function runCore() {
+    if (EZOIC_BLOCKED) return;
+
+    patchShowAds();
+
+    const cfg = await fetchConfigOnce();
+    if (!cfg || cfg.excluded) return;
+    initPools(cfg);
+
+    const kind = getKind();
+
+    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
+        );
+      }
+    } 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
+        );
+      }
+    } 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 cleanupForNav() {
-    // New token => any pending safeCmd work becomes stale
-    state.pageToken += 1;
-    state.cfg = null;
-    state.cfgPromise = null;
-    state.lastShowAt.clear();
+  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 ----------
 
-    // Disconnect observers for old DOM
-    try { if (state.io) state.io.disconnect(); } catch (e) {}
-    state.io = null;
-    try { if (state.mo) state.mo.disconnect(); } catch (e) {}
-    state.mo = null;
+  function cleanup() {
+    EZOIC_BLOCKED = true;
 
-    removeAllAds();
+    // remove all wrappers
+    try {
+      document.querySelectorAll(`.${WRAP_CLASS}`).forEach((el) => {
+        try { el.remove(); } catch (e) {}
+      });
+    } 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)
   }
 
-  // ----------------------------
-  // Bind to NodeBB 4.x ajaxify events
-  // ----------------------------
-  function bind() {
+  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', () => cleanupForNav());
+    $(window).on('action:ajaxify.start.ezoicInfinite', () => {
+      cleanup();
+    });
 
     $(window).on('action:ajaxify.end.ezoicInfinite', () => {
       state.pageKey = getPageKey();
-      ensureMO();
-      schedule(runCore);
+      EZOIC_BLOCKED = false;
+
+      warmUpNetwork();
+      patchShowAds();
+      ensurePreloadObserver();
+      ensureDomObserver();
+
+      // Ultra-fast above-the-fold first
+      insertHeroAdEarly().catch(() => {});
+
+      // Then normal insertion
+      scheduleRun();
     });
 
-    // Infinite scroll hooks
-    $(window).on('action:posts.loaded.ezoicInfinite', () => schedule(runCore));
-    $(window).on('action:topics.loaded.ezoicInfinite', () => schedule(runCore));
-    $(window).on('action:category.loaded.ezoicInfinite', () => schedule(runCore));
-    $(window).on('action:topic.loaded.ezoicInfinite', () => schedule(runCore));
+    // 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();
+    });
   }
 
-  // Boot
-  cleanupForNav();
-  bind();
-  ensureMO();
+  function bindScroll() {
+    let ticking = false;
+    window.addEventListener('scroll', () => {
+      if (ticking) return;
+      ticking = true;
+      window.requestAnimationFrame(() => {
+        ticking = false;
+        if (!EZOIC_BLOCKED) scheduleRun();
+      });
+    }, { passive: true });
+  }
+
+  // ---------- boot ----------
+
   state.pageKey = getPageKey();
-  schedule(runCore);
-})();
+  warmUpNetwork();
+  patchShowAds();
+  ensurePreloadObserver();
+  ensureDomObserver();
+
+  bindNodeBB();
+  bindScroll();
+
+  // First paint: try hero + run
+  EZOIC_BLOCKED = false;
+  insertHeroAdEarly().catch(() => {});
+  scheduleRun();
+})();

package/public/style.css

@@ -1,7 +1,21 @@
-.ezoic-ad,
-.ezoic-ad *,
-span.ezoic-ad,
-span[class*="ezoic"] {
-  min-height: 0 !important;
-  min-width: 0 !important;
-}
+/* 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 > [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;
+}