nodebb-plugin-ezoic-infinite 1.5.22 → 1.5.24

package/library.js

@@ -9,11 +9,7 @@ const plugin = {};
 
 function normalizeExcludedGroups(value) {
   if (!value) return [];
-  // NodeBB settings may return arrays, strings, or objects like {0:'a',1:'b'}
-  if (Array.isArray(value)) return value.map(String).map(s => s.trim()).filter(Boolean);
-  if (typeof value === 'object') {
-    return Object.values(value).map(String).map(s => s.trim()).filter(Boolean);
-  }
+  if (Array.isArray(value)) return value;
   return String(value).split(',').map(s => s.trim()).filter(Boolean);
 }
 
@@ -70,19 +66,9 @@ async function getSettings() {
 }
 
 async function isUserExcluded(uid, excludedGroups) {
-  const list = (excludedGroups || []).map(g => String(g).toLowerCase());
-  const id = Number(uid) || 0;
-
-  if (!list.length) return false;
-
-  // Guests (uid=0) are not in groups.getUserGroups; treat explicitly if configured
-  if (id === 0) {
-    return list.includes('guests') || list.includes('guest');
-  }
-
-  const userGroups = await groups.getUserGroups([id]);
-  const names = (userGroups[0] || []).map(g => (g && g.name) ? g.name : String(g));
-  return names.some(name => list.includes(String(name).toLowerCase()));
+  if (!uid || !excludedGroups.length) return false;
+  const userGroups = await groups.getUserGroups([uid]);
+  return (userGroups[0] || []).some(g => excludedGroups.includes(g.name));
 }
 
 plugin.onSettingsSet = function (data) {
@@ -121,11 +107,7 @@ plugin.init = async ({ router, middleware }) => {
 
   router.get('/api/plugins/ezoic-infinite/config', async (req, res) => {
     const settings = await getSettings();
-    const uid = (typeof req.uid !== 'undefined' && req.uid !== null) ? req.uid
-      : (req.user && req.user.uid) ? req.user.uid
-      : (res.locals && res.locals.uid) ? res.locals.uid
-      : 0;
-    const excluded = await isUserExcluded(uid, settings.excludedGroups);
+    const excluded = await isUserExcluded(req.uid, settings.excludedGroups);
 
     res.json({
       excluded,

package/package.json

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

package/public/client.js

@@ -1,93 +1,64 @@
 (function () {
   'use strict';
 
-  var $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
+  // NodeBB client context
+  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
 
-  var SELECTORS = {
-    topicItem: 'li[component="category/topic"]',
-    postItem: '[component="post"][data-pid]',
-    categoryItem: 'li[component="categories/category"]'
-  };
+  const WRAP_CLASS = 'ezoic-ad';
+  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
 
-  var WRAP_CLASS = 'ezoic-ad';
-  var 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;
 
-  // Hard limits to avoid runaway insertion during mutations / infinite scroll.
-  var MAX_INSERTS_PER_RUN = 3;
+  // Preload before viewport (tune if you want even earlier)
+  const PRELOAD_ROOT_MARGIN = '1200px 0px';
 
-  // Placeholders that have been "defined" (filled) at least once in this browser session.
-  // This survives ajaxify navigations, which is important for safe recycle/destroy logic.
-  var sessionDefinedIds = new Set();
+  const SELECTORS = {
+    topicItem: 'li[component="category/topic"]',
+    postItem: '[component="post"][data-pid]',
+    categoryItem: 'li[component="categories/category"]',
+  };
 
-  // Prevent re-entrant insertion of the same id while Ezoic is processing it.
-  var insertingIds = new Set();
+  // Hard block during navigation to avoid “placeholder does not exist” spam
+  let EZOIC_BLOCKED = false;
 
-  var state = {
+  const state = {
     pageKey: null,
-
     cfg: null,
-    cfgPromise: null,
 
-    poolTopics: [],
-    poolPosts: [],
-    poolCategories: [],
+    // Full lists (never consumed) + cursors for round-robin reuse
+    allTopics: [],
+    allPosts: [],
+    allCategories: [],
+    curTopics: 0,
+    curPosts: 0,
+    curCategories: 0,
 
-    usedTopics: new Set(),
-    usedPosts: new Set(),
-    usedCategories: new Set(),
-
-    // Track wrappers that are still in the DOM to recycle ids once they are far above viewport.
-    liveTopics: [],
-    livePosts: [],
-    liveCategories: [],
-
-    // Throttle showAds calls per id.
+    // throttle per placeholder id
     lastShowById: new Map(),
 
-    // Ids for which we scheduled/attempted showAds and should not schedule again immediately.
-    pendingById: new Set(),
-
-    // Timeouts created by this script (so we can cancel on ajaxify.start).
-    activeTimeouts: new Set(),
-
-    // Run scheduling / mutation observer.
-    scheduled: false,
-    timer: null,
-    obs: null,
+    // observers / schedulers
+    domObs: null,
+    io: null,
+    runQueued: false,
 
-    // Scroll throttling.
-    lastScrollRun: 0,
+    // hero
+    heroDoneForPage: false,
+  };
 
-    // Navigation safety gate: we only insert after ajaxify.end settles.
-    canShowAds: false,
+  const insertingIds = new Set();
 
-    // Retry counters.
-    poolWaitAttempts: 0,
-    awaitItemsAttempts: 0
-  };
+  // ---------- small utils ----------
 
   function normalizeBool(v) {
     return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
-  function setTimeoutTracked(fn, ms) {
-    var id = setTimeout(fn, ms);
-    state.activeTimeouts.add(id);
-    return id;
-  }
-
-  function clearAllTrackedTimeouts() {
-    state.activeTimeouts.forEach(function (id) {
-      try { clearTimeout(id); } catch (e) {}
-    });
-    state.activeTimeouts.clear();
-  }
-
   function uniqInts(lines) {
-    var out = [];
-    var seen = new Set();
-    for (var i = 0; i < lines.length; i++) {
-      var n = parseInt(lines[i], 10);
+    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);
@@ -98,31 +69,31 @@
 
   function parsePool(raw) {
     if (!raw) return [];
-    var lines = String(raw)
+    const lines = String(raw)
       .split(/\r?\n/)
-      .map(function (s) { return s.trim(); })
+      .map(s => s.trim())
       .filter(Boolean);
     return uniqInts(lines);
   }
 
   function getPageKey() {
     try {
-      var ax = window.ajaxify;
+      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;
+        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() {
-    var p = window.location.pathname || '';
+    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.
+    // fallback by DOM
     if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
     if (document.querySelector(SELECTORS.postItem)) return 'topic';
     if (document.querySelector(SELECTORS.topicItem)) return 'categoryTopics';
@@ -138,710 +109,493 @@
   }
 
   function getPostContainers() {
-    var nodes = Array.from(document.querySelectorAll(SELECTORS.postItem));
-    return nodes.filter(function (el) {
+    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;
-
-      // Prevent nested / duplicated post wrappers.
-      var parentPost = el.parentElement && el.parentElement.closest('[component="post"][data-pid]');
+      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 safeRect(el) {
-    try { return el.getBoundingClientRect(); } catch (e) { return null; }
-  }
+  // ---------- warm-up & patching ----------
 
-  function destroyPlaceholderIds(ids) {
-    if (!ids || !ids.length) return;
-
-    // Only destroy ids that were actually "defined" (filled at least once) to avoid Ezoic warnings.
-    var filtered = ids.filter(function (id) {
-      try { return sessionDefinedIds.has(id); } catch (e) { return true; }
-    });
-
-    if (!filtered.length) return;
+  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) {}
+  }
 
-    var call = function () {
+  // Patch showAds to avoid warnings when a placeholder disappears (infinite scroll, ajaxify)
+  function patchShowAds() {
+    const applyPatch = () => {
       try {
-        if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
-          window.ezstandalone.destroyPlaceholders(filtered);
-        }
+        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) {}
     };
 
-        try {
-      // Do NOT initialize ezstandalone here; if you load Ezoic elsewhere, it will manage its own queue.
-      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
-        call();
-      } else if (window.ezstandalone && window.ezstandalone.cmd && Array.isArray(window.ezstandalone.cmd)) {
-        window.ezstandalone.cmd.push(call);
-      }
-    } catch (e) {}}
-
-  function getRecyclable(liveArr) {
-    var margin = 600; // px above viewport
-    for (var i = 0; i < liveArr.length; i++) {
-      var entry = liveArr[i];
-      if (!entry || !entry.wrap || !entry.wrap.isConnected) {
-        liveArr.splice(i, 1);
-        i--;
-        continue;
-      }
-      var r = safeRect(entry.wrap);
-      if (r && r.bottom < -margin) {
-        liveArr.splice(i, 1);
-        return entry;
-      }
+    applyPatch();
+    if (!window.__nodebbEzoicPatched) {
+      try {
+        window.ezstandalone = window.ezstandalone || {};
+        window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+        window.ezstandalone.cmd.push(applyPatch);
+      } catch (e) {}
     }
-    return null;
   }
 
-  function pickId(pool, liveArr) {
-    if (pool.length) return { id: pool.shift(), recycled: null };
+  // ---------- config & pools ----------
 
-    var recycled = getRecyclable(liveArr);
-    if (recycled) return { id: recycled.id, recycled: recycled };
+  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;
+    }
+  }
 
-    return { id: null, recycled: null };
+  function initPools(cfg) {
+    if (!cfg) return;
+    if (state.allTopics.length === 0) state.allTopics = parsePool(cfg.placeholderIds);
+    if (state.allPosts.length === 0) state.allPosts = parsePool(cfg.messagePlaceholderIds);
+    if (state.allCategories.length === 0) state.allCategories = parsePool(cfg.categoryPlaceholderIds);
   }
 
-  function resetPlaceholderInWrap(wrap, id) {
-    if (!wrap) return null;
-    try { wrap.innerHTML = ''; } catch (e) {}
+  // ---------- insertion primitives ----------
 
-    var ph = document.createElement('div');
-    ph.id = PLACEHOLDER_PREFIX + id;
-    wrap.appendChild(ph);
-    return ph;
+  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 isAdjacentAd(el) {
-    var next = el && el.nextElementSibling;
-    return !!(next && next.classList && next.classList.contains(WRAP_CLASS));
-  }
+  function buildWrap(id, kindClass, afterPos) {
+    const wrap = document.createElement('div');
+    wrap.className = `${WRAP_CLASS} ${kindClass}`;
+    wrap.setAttribute('data-ezoic-after', String(afterPos));
+    wrap.style.width = '100%';
 
-  function isPrevAd(el) {
-    var prev = el && el.previousElementSibling;
-    return !!(prev && prev.classList && prev.classList.contains(WRAP_CLASS));
-  }
+    const ph = document.createElement('div');
+    ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+    ph.setAttribute('data-ezoic-id', String(id));
+    wrap.appendChild(ph);
 
-  function buildWrap(id, kindClass) {
-    var wrap = document.createElement('div');
-    wrap.className = WRAP_CLASS + ' ' + kindClass;
-    wrap.setAttribute('data-ezoic-id', String(id));
-    resetPlaceholderInWrap(wrap, id);
     return wrap;
   }
 
   function findWrap(kindClass, afterPos) {
-    // Search a wrapper marker that we set on insertion.
-    return document.querySelector('.' + kindClass + '[data-after-pos="' + afterPos + '"]');
+    return document.querySelector(`.${WRAP_CLASS}.${kindClass}[data-ezoic-after="${afterPos}"]`);
   }
 
-  function insertAfter(el, id, kindClass, afterPos) {
-    try {
-      var wrap = buildWrap(id, kindClass);
-      wrap.setAttribute('data-after-pos', String(afterPos));
+  function insertAfter(target, id, kindClass, afterPos) {
+    if (!target || !target.insertAdjacentElement) return null;
+    if (findWrap(kindClass, afterPos)) return null;
+    if (insertingIds.has(id)) return null;
 
-      if (!el || !el.parentNode) return null;
-      if (el.nextSibling) el.parentNode.insertBefore(wrap, el.nextSibling);
-      else el.parentNode.appendChild(wrap);
+    const existingPh = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+    if (existingPh && existingPh.isConnected) return null;
 
-      attachFillObserver(wrap, id);
+    insertingIds.add(id);
+    try {
+      const wrap = buildWrap(id, kindClass, afterPos);
+      target.insertAdjacentElement('afterend', wrap);
       return wrap;
-    } catch (e) {}
-    return null;
-  }
-
-  function destroyUsedPlaceholders() {
-    var ids = [];
-    state.usedTopics.forEach(function (id) { ids.push(id); });
-    state.usedPosts.forEach(function (id) { ids.push(id); });
-    state.usedCategories.forEach(function (id) { ids.push(id); });
-
-    // Only destroy placeholders that were filled at least once in this session.
-    destroyPlaceholderIds(ids);
-  }
-
-  function patchShowAds() {
-    // Intentionally left blank: ezstandalone is managed elsewhere.
+    } finally {
+      insertingIds.delete(id);
+    }
   }
 
-  function markFilled(id) {
-    try { sessionDefinedIds.add(id); } catch (e) {}
-  }
+  function pickIdFromAll(allIds, cursorKey) {
+    const n = allIds.length;
+    if (!n) return null;
 
-  function isWrapMarkedFilled(wrap) {
-    try { return !!(wrap && wrap.getAttribute && wrap.getAttribute('data-ezoic-filled') === '1'); } catch (e) { return false; }
-  }
+    // Try at most n ids to find one that's not already in the DOM
+    for (let tries = 0; tries < n; tries++) {
+      const idx = state[cursorKey] % n;
+      state[cursorKey] = (state[cursorKey] + 1) % n;
 
-  function attachFillObserver(wrap, id) {
-    if (!wrap || !wrap.isConnected) return;
+      const id = allIds[idx];
+      const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+      if (ph && ph.isConnected) continue;
 
-    // If already filled, mark and return.
-    if (isPlaceholderFilled(wrap)) {
-      try { wrap.setAttribute('data-ezoic-filled', '1'); } catch (e) {}
-      markFilled(id);
-      return;
+      return id;
     }
-
-    // Observe for Ezoic inserting ad content into placeholder.
-    try {
-      var obs = new MutationObserver(function () {
-        if (!wrap.isConnected) {
-          try { obs.disconnect(); } catch (e) {}
-          return;
-        }
-        if (isPlaceholderFilled(wrap)) {
-          try { wrap.setAttribute('data-ezoic-filled', '1'); } catch (e) {}
-          markFilled(id);
-          try { obs.disconnect(); } catch (e) {}
-        }
-      });
-      obs.observe(wrap, { childList: true, subtree: true });
-      wrap.__ezoicFillObs = obs;
-    } catch (e) {}
+    return null;
   }
 
-  function isPlaceholderFilled(wrap) {
-    // Heuristic: placeholder exists AND has descendants or meaningful height.
-    try {
-      var ph = wrap.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
-      if (!ph) return false;
-      if (ph.children && ph.children.length) return true;
-      var r = safeRect(wrap);
-      if (r && r.height > 20) return true;
-    } catch (e) {}
-    return false;
-  }
+  function showAd(id) {
+    if (!id || EZOIC_BLOCKED) return;
 
-  function scheduleShowAdsBatch(ids) {
-    if (!ids || !ids.length) return;
+    const now = Date.now();
+    const last = state.lastShowById.get(id) || 0;
+    if (now - last < 1500) return; // basic throttle
 
-    // Ezoic expects DOM to be settled.
-    var call = function () {
-      try {
-        if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') {
-          window.ezstandalone.showAds(ids);
-        }
-      } catch (e) {}
-    };
+    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+    if (!ph || !ph.isConnected) return;
 
-    try {
-      if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') call();
-      else if (window.ezstandalone && window.ezstandalone.cmd && Array.isArray(window.ezstandalone.cmd)) window.ezstandalone.cmd.push(call);
-    } catch (e) {}
-  }
-
-  function callShowAdsWhenReady(id) {
-    if (!id) return;
-
-    // Throttle per-id.
-    var now = Date.now();
-    var last = state.lastShowById.get(id) || 0;
-    if (now - last < 1200) return;
-
-    if (state.pendingById.has(id)) return;
-    state.pendingById.add(id);
     state.lastShowById.set(id, now);
 
-    // Guard against re-entrancy.
-    if (insertingIds.has(id)) {
-      state.pendingById.delete(id);
-      return;
-    }
-    insertingIds.add(id);
-
-    var attempts = 0;
-
-    (function waitForPh() {
-      attempts++;
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      const ez = window.ezstandalone;
 
-      // Navigation safety: if we navigated away, stop.
-      if (!state.canShowAds) {
-        state.pendingById.delete(id);
-        insertingIds.delete(id);
+      // Fast path
+      if (typeof ez.showAds === 'function') {
+        ez.showAds(id);
         return;
       }
 
-      var ph = document.getElementById(PLACEHOLDER_PREFIX + id);
-
-      var doCall = function () {
-        try {
-          // If placeholder is gone, stop.
-          if (!ph || !ph.isConnected) return false;
-          scheduleShowAdsBatch([id]);
-          return true;
-        } catch (e) {}
-        return false;
-      };
-
-      if (ph && ph.isConnected) {
-        doCall();
-        state.pendingById.delete(id);
-        insertingIds.delete(id);
-        return;
+      // 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);
+          } catch (e) {}
+        });
       }
+    } catch (e) {}
+  }
 
-      if (attempts < 100) {
-        setTimeoutTracked(waitForPh, 50);
-        return;
-      }
+  // ---------- preload / above-the-fold ----------
 
-      // Timeout: give up silently.
-      state.pendingById.delete(id);
-      insertingIds.delete(id);
-    })();
+  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;
   }
 
-  function initPools(cfg) {
-    if (!state.poolTopics.length) state.poolTopics = parsePool(cfg.placeholderIds);
-    if (!state.poolPosts.length) state.poolPosts = parsePool(cfg.messagePlaceholderIds);
-    if (!state.poolCategories.length) state.poolCategories = parsePool(cfg.categoryPlaceholderIds);
+  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 ----------
+
   function computeTargets(count, interval, showFirst) {
-    var out = [];
+    const out = [];
     if (count <= 0) return out;
-
     if (showFirst) out.push(1);
-
-    for (var i = 1; i <= count; i++) {
+    for (let i = 1; i <= count; i++) {
       if (i % interval === 0) out.push(i);
     }
-
-    // Unique + sorted.
-    return Array.from(new Set(out)).sort(function (a, b) { return a - b; });
+    return Array.from(new Set(out)).sort((a, b) => a - b);
   }
 
-  function injectBetween(kindClass, items, interval, showFirst, kindPool, usedSet, liveArr) {
-    if (!items || !items.length) return 0;
+  function injectBetween(kindClass, items, interval, showFirst, allIds, cursorKey) {
+    if (!items.length) return 0;
 
-    var targets = computeTargets(items.length, interval, showFirst);
-    var inserted = 0;
+    const targets = computeTargets(items.length, interval, showFirst);
+    let inserted = 0;
 
-    for (var t = 0; t < targets.length; t++) {
-      var afterPos = targets[t];
+    for (const afterPos of targets) {
       if (inserted >= MAX_INSERTS_PER_RUN) break;
 
-      var el = items[afterPos - 1];
+      const el = items[afterPos - 1];
       if (!el || !el.isConnected) continue;
-
-      // Prevent adjacent ads.
-      if (isAdjacentAd(el) || isPrevAd(el)) continue;
-
-      // Prevent duplicates at same logical position.
-      if (findWrap(kindClass, afterPos - 1)) continue;
+      if (isAdjacentAd(el)) continue;
       if (findWrap(kindClass, afterPos)) continue;
 
-      var pick = pickId(kindPool, liveArr);
-      var id = pick.id;
+      const id = pickIdFromAll(allIds, cursorKey);
       if (!id) break;
-
-      var wrap = null;
-
-      if (pick.recycled && pick.recycled.wrap) {
-        // Recycle: only destroy if Ezoic has actually defined this placeholder before.
-        if (sessionDefinedIds.has(id)) destroyPlaceholderIds([id]);
-
-        // Remove old wrapper.
-        var oldWrap = pick.recycled.wrap;
-        try { if (oldWrap && oldWrap.__ezoicFillObs) oldWrap.__ezoicFillObs.disconnect(); } catch (e) {}
-        try { if (oldWrap) oldWrap.remove(); } catch (e) {}
-
-        wrap = insertAfter(el, id, kindClass, afterPos);
-        if (!wrap) continue;
-
-        // Give Ezoic a moment after DOM insertion.
-        setTimeoutTracked(function () { callShowAdsWhenReady(id); }, 700);
-      } else {
-        usedSet.add(id);
-        wrap = insertAfter(el, id, kindClass, afterPos);
-        if (!wrap) continue;
-
-        // Micro-delay to allow layout/DOM settle.
-        setTimeoutTracked(function () { callShowAdsWhenReady(id); }, 10);
-      }
-
-      liveArr.push({ id: id, wrap: wrap });
-
-      // Final safety: if adjacency happened due to DOM shifts, rollback.
-      var prev = wrap && wrap.previousElementSibling;
-      var next = wrap && wrap.nextElementSibling;
-      if (wrap && ((prev && prev.classList && prev.classList.contains(WRAP_CLASS)) || (next && next.classList && next.classList.contains(WRAP_CLASS)))) {
-        try { wrap.remove(); } catch (e) {}
-
-        if (!(pick.recycled && pick.recycled.wrap)) {
-          try { kindPool.unshift(id); } catch (e) {}
-          usedSet.delete(id);
-        }
+      const wrap = insertAfter(el, id, kindClass, afterPos);
+      if (!wrap) {
         continue;
       }
 
-      inserted++;
+      observePlaceholder(id);
+      inserted += 1;
     }
 
     return inserted;
   }
 
-  function enforceNoAdjacentAds() {
-    var ads = Array.from(document.querySelectorAll('.' + WRAP_CLASS));
-    for (var i = 0; i < ads.length; i++) {
-      var ad = ads[i];
-      var prev = ad.previousElementSibling;
-
-      if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) {
-        // Remove adjacent wrapper (do not hide).
-        try {
-          var ph = ad.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
-          if (ph) {
-            var id = parseInt(ph.id.replace(PLACEHOLDER_PREFIX, ''), 10);
-            if (Number.isFinite(id) && id > 0 && sessionDefinedIds.has(id)) {
-              destroyPlaceholderIds([id]);
-            }
-          }
-          ad.remove();
-        } catch (e) {}
-      }
-    }
-  }
-
-  function cleanup() {
-    // Stop any insertion during navigation / DOM teardown.
-    state.canShowAds = false;
-    state.poolWaitAttempts = 0;
-    state.awaitItemsAttempts = 0;
-
-    // Cancel any pending showAds timeouts.
-    clearAllTrackedTimeouts();
-
-    // Disconnect global observer to avoid mutations during teardown.
-    if (state.obs) {
-      try { state.obs.disconnect(); } catch (e) {}
-      state.obs = null;
+  async function insertHeroAdEarly() {
+    if (state.heroDoneForPage) return;
+    const cfg = await fetchConfigOnce();
+    if (!cfg || cfg.excluded) return;
+
+    initPools(cfg);
+
+    const kind = getKind();
+    let items = [];
+    let allIds = [];
+    let cursorKey = '';
+    let kindClass = '';
+    let showFirst = false;
+
+    if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
+      items = getPostContainers();
+      allIds = state.allPosts;
+      cursorKey = 'curPosts';
+      kindClass = 'ezoic-ad-message';
+      showFirst = normalizeBool(cfg.showFirstMessageAd);
+    } else if (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
+      items = getTopicItems();
+      allIds = state.allTopics;
+      cursorKey = 'curTopics';
+      kindClass = 'ezoic-ad-between';
+      showFirst = normalizeBool(cfg.showFirstTopicAd);
+    } else if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
+      items = getCategoryItems();
+      allIds = state.allCategories;
+      cursorKey = 'curCategories';
+      kindClass = 'ezoic-ad-categories';
+      showFirst = normalizeBool(cfg.showFirstCategoryAd);
+    } else {
+      return;
     }
 
-    // Destroy placeholders that were used (only those that were actually defined).
-    destroyUsedPlaceholders();
+    if (!items.length) return;
+    if (!showFirst) { state.heroDoneForPage = true; return; }
 
-    // Remove wrappers from DOM (safe because insertion is now blocked).
-    try {
-      document.querySelectorAll('.' + WRAP_CLASS).forEach(function (el) {
-        try { if (el && el.__ezoicFillObs) el.__ezoicFillObs.disconnect(); } catch (e) {}
-        try { el.remove(); } catch (e) {}
-      });
-    } catch (e) {}
-
-    // Reset runtime caches.
-    state.pageKey = getPageKey();
-    state.cfg = null;
-    state.cfgPromise = null;
+    // 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; }
 
-    state.poolTopics = [];
-    state.poolPosts = [];
-    state.poolCategories = [];
-
-    state.usedTopics.clear();
-    state.usedPosts.clear();
-    state.usedCategories.clear();
-
-    state.liveTopics = [];
-    state.livePosts = [];
-    state.liveCategories = [];
-
-    state.lastShowById.clear();
-    state.pendingById.clear();
-    insertingIds.clear();
-
-    state.scheduled = false;
-    if (state.timer) {
-      try { clearTimeout(state.timer); } catch (e) {}
-      state.timer = null;
-    }
-  }
-
-  function ensureObserver() {
-    if (state.obs) return;
-    try {
-      state.obs = new MutationObserver(function () { scheduleRun('mutation'); });
-      state.obs.observe(document.body, { childList: true, subtree: true });
-    } catch (e) {}
-  }
-
-  function scheduleRun(/* reason */) {
-    if (state.scheduled) return;
-    state.scheduled = true;
+    const id = pickIdFromAll(allIds, cursorKey);
+    if (!id) return;
 
-    if (state.timer) {
-      try { clearTimeout(state.timer); } catch (e) {}
-      state.timer = null;
+    const wrap = insertAfter(el, id, kindClass, afterPos);
+    if (!wrap) {
+      return;
     }
 
-    state.timer = setTimeoutTracked(function () {
-      state.scheduled = false;
-
-      // If user navigated away, stop.
-      var pk = getPageKey();
-      if (state.pageKey && pk !== state.pageKey) return;
-
-      runCore().catch(function () {});
-    }, 80);
+    state.heroDoneForPage = true;
+    observePlaceholder(id);
   }
 
-  function waitForItemsThenRun(kind) {
-    // If list isn't in DOM yet (ajaxify transition), retry a bit.
-    var count = 0;
-    if (kind === 'topic') count = getPostContainers().length;
-    else if (kind === 'categoryTopics') count = getTopicItems().length;
-    else if (kind === 'categories') count = getCategoryItems().length;
+  async function runCore() {
+    if (EZOIC_BLOCKED) return;
 
-    if (count > 0) return true;
-
-    if (state.awaitItemsAttempts < 25) {
-      state.awaitItemsAttempts++;
-      setTimeoutTracked(function () { scheduleRun('await-items'); }, 120);
-    }
-    return false;
-  }
-
-  function waitForContentThenRun() {
-    // Avoid inserting ads on pages with too little content.
-    var MIN_WORDS = 250;
-    var attempts = 0;
-    var maxAttempts = 20; // 20 × 200ms = 4s
-
-    (function check() {
-      attempts++;
-
-      var text = '';
-      try { text = document.body.innerText || ''; } catch (e) {}
-      var wordCount = text.split(/\s+/).filter(Boolean).length;
-
-      if (wordCount >= MIN_WORDS) {
-        scheduleRun('content-ok');
-        return;
-      }
+    patchShowAds();
 
-      if (attempts >= maxAttempts) {
-        scheduleRun('content-timeout');
-        return;
+    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.allPosts,
+          'curPosts'
+        );
       }
-
-      setTimeoutTracked(check, 200);
-    })();
-  }
-
-  function waitForEzoicThenRun() {
-    var attempts = 0;
-    var maxAttempts = 50; // 50 × 200ms = 10s
-
-    (function check() {
-      attempts++;
-
-      if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') {
-        scheduleRun('ezoic-ready');
-        waitForContentThenRun();
-        return;
+    } 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.allTopics,
+          'curTopics'
+        );
       }
-
-      if (attempts >= maxAttempts) {
-        scheduleRun('ezoic-timeout');
-        return;
+    } 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.allCategories,
+          'curCategories'
+        );
       }
-
-      setTimeoutTracked(check, 200);
-    })();
+    }
   }
 
-  function fetchConfig() {
-    if (state.cfg) return Promise.resolve(state.cfg);
-    if (state.cfgPromise) return state.cfgPromise;
-
-    state.cfgPromise = (function () {
-      var MAX_TRIES = 3;
-      var delay = 800;
-
-      function attemptFetch(attempt) {
-        return fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' })
-          .then(function (res) {
-            if (!res || !res.ok) throw new Error('bad response');
-            return res.json();
-          })
-          .then(function (json) {
-            state.cfg = json;
-            return json;
-          })
-          .catch(function () {
-            if (attempt >= MAX_TRIES) return null;
-            return new Promise(function (r) { setTimeoutTracked(r, delay); }).then(function () {
-              delay *= 2;
-              return attemptFetch(attempt + 1);
-            });
-          });
-      }
-
-      return attemptFetch(1).finally(function () { state.cfgPromise = null; });
-    })();
-
-    return state.cfgPromise;
+  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(() => {});
+    });
   }
 
-  function runCore() {
-    // Navigation safety: never insert during ajaxify teardown.
-    if (!state.canShowAds) return Promise.resolve();
-
-    patchShowAds();
-
-    return fetchConfig().then(function (cfg) {
-      if (!cfg || cfg.excluded) return;
+  // ---------- observers / lifecycle ----------
 
-      initPools(cfg);
-
-      var kind = getKind();
-      var inserted = 0;
-
-      if (!waitForItemsThenRun(kind)) return;
+  function cleanup() {
+    EZOIC_BLOCKED = true;
 
-      if (kind === 'topic') {
-        if (normalizeBool(cfg.enableMessageAds)) {
-          inserted = injectBetween(
-            'ezoic-ad-message',
-            getPostContainers(),
-            Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
-            normalizeBool(cfg.showFirstMessageAd),
-            state.poolPosts,
-            state.usedPosts,
-            state.livePosts
-          );
-        }
-      } else if (kind === 'categoryTopics') {
-        if (normalizeBool(cfg.enableBetweenAds)) {
-          inserted = injectBetween(
-            'ezoic-ad-between',
-            getTopicItems(),
-            Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
-            normalizeBool(cfg.showFirstTopicAd),
-            state.poolTopics,
-            state.usedTopics,
-            state.liveTopics
-          );
-        }
-      } else if (kind === 'categories') {
-        if (normalizeBool(cfg.enableCategoryAds)) {
-          inserted = injectBetween(
-            'ezoic-ad-categories',
-            getCategoryItems(),
-            Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
-            normalizeBool(cfg.showFirstCategoryAd),
-            state.poolCategories,
-            state.usedCategories,
-            state.liveCategories
-          );
-        }
-      }
+    // remove all wrappers
+    try {
+      document.querySelectorAll(`.${WRAP_CLASS}`).forEach((el) => {
+        try { el.remove(); } catch (e) {}
+      });
+    } catch (e) {}
 
-      enforceNoAdjacentAds();
+    // reset state
+    state.cfg = null;
+    state.allTopics = [];
+    state.allPosts = [];
+    state.allCategories = [];
+    state.curTopics = 0;
+    state.curPosts = 0;
+    state.curCategories = 0;
+    state.lastShowById.clear();
+    state.heroDoneForPage = false;
 
-      // Recycling: if pool is exhausted, retry a few times to allow old wrappers to scroll off-screen.
-      if (inserted === 0) {
-        if (state.poolWaitAttempts < 8) {
-          state.poolWaitAttempts++;
-          setTimeoutTracked(function () { scheduleRun('pool-wait'); }, 400);
-        }
-      } else {
-        // Reset pool wait attempts once we successfully insert something.
-        state.poolWaitAttempts = 0;
-      }
+    // keep observers alive (MutationObserver will re-trigger after navigation)
+  }
 
-      // If we hit max inserts, continue quickly.
-      if (inserted >= MAX_INSERTS_PER_RUN) {
-        setTimeoutTracked(function () { scheduleRun('continue'); }, 140);
-      }
-    }).catch(function () {});
+  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 bind() {
+  function bindNodeBB() {
     if (!$) return;
 
     $(window).off('.ezoicInfinite');
 
-    $(window).on('action:ajaxify.start.ezoicInfinite', function () {
+    $(window).on('action:ajaxify.start.ezoicInfinite', () => {
       cleanup();
     });
 
-    $(window).on('action:ajaxify.end.ezoicInfinite', function () {
+    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
       state.pageKey = getPageKey();
-      ensureObserver();
+      EZOIC_BLOCKED = false;
 
-      // Delay gate to avoid racing NodeBB DOM swap vs Ezoic processing.
-      setTimeoutTracked(function () {
-        state.canShowAds = true;
-        waitForEzoicThenRun();
-      }, 300);
-    });
+      warmUpNetwork();
+      patchShowAds();
+      ensurePreloadObserver();
+      ensureDomObserver();
 
-    // Infinite-scroll and "loaded" events.
-    $(window).on('action:category.loaded.ezoicInfinite', function () {
-      ensureObserver();
-      waitForContentThenRun();
-    });
+      // Ultra-fast above-the-fold first
+      insertHeroAdEarly().catch(() => {});
 
-    $(window).on('action:topics.loaded.ezoicInfinite', function () {
-      ensureObserver();
-      waitForContentThenRun();
+      // Then normal insertion
+      scheduleRun();
     });
 
-    $(window).on('action:topic.loaded.ezoicInfinite', function () {
-      ensureObserver();
-      waitForContentThenRun();
-    });
-
-    $(window).on('action:posts.loaded.ezoicInfinite', function () {
-      ensureObserver();
-      waitForContentThenRun();
+    // 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();
     });
   }
 
   function bindScroll() {
-    if (state.lastScrollRun > 0) return;
-    state.lastScrollRun = Date.now();
-
-    var ticking = false;
-    window.addEventListener('scroll', function () {
+    let ticking = false;
+    window.addEventListener('scroll', () => {
       if (ticking) return;
       ticking = true;
-
-      window.requestAnimationFrame(function () {
+      window.requestAnimationFrame(() => {
         ticking = false;
-
-        enforceNoAdjacentAds();
-
-        // Debounce scheduleRun (max once every 2s on scroll).
-        var now = Date.now();
-        if (!state.lastScrollRun || (now - state.lastScrollRun > 2000)) {
-          state.lastScrollRun = now;
-          scheduleRun('scroll');
-        }
+        if (!EZOIC_BLOCKED) scheduleRun();
       });
     }, { passive: true });
   }
 
-  // Boot.
-  cleanup();
-  bind();
-  bindScroll();
-  ensureObserver();
+  // ---------- boot ----------
 
   state.pageKey = getPageKey();
+  warmUpNetwork();
+  patchShowAds();
+  ensurePreloadObserver();
+  ensureDomObserver();
+
+  bindNodeBB();
+  bindScroll();
 
-  // Direct page load: allow insertion after initial tick (no ajaxify.end).
-  setTimeoutTracked(function () {
-    state.canShowAds = true;
-    waitForEzoicThenRun();
-  }, 0);
+  // First paint: try hero + run
+  EZOIC_BLOCKED = false;
+  insertHeroAdEarly().catch(() => {});
+  scheduleRun();
 })();