nodebb-plugin-ezoic-infinite 1.0.18 → 1.1.0

package/README.md

@@ -0,0 +1,15 @@
+# NodeBB Plugin – Ezoic Infinite (Production)
+
+This plugin injects Ezoic placeholders between topics and posts on NodeBB 4.x,
+with full support for infinite scroll.
+
+## Key guarantees
+- No duplicate ads back-to-back
+- One showAds call per placeholder
+- Fast reveal (MutationObserver on first child)
+- Safe with ajaxify navigation
+- Works with NodeBB 4.x + Harmony
+
+## Notes
+- Placeholders must exist and be selected in Ezoic
+- Use separate ID pools for topics vs messages

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.0.18",
-  "description": "Ezoic ads with infinite scroll using a pool of placeholder IDs",
+  "version": "1.1.0",
+  "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",
   "keywords": [
@@ -12,9 +12,10 @@
     "infinite-scroll"
   ],
   "engines": {
-    "node": ">=18"
+    "nodebb": ">=4.0.0"
   },
   "nbbpm": {
     "compatibility": "^4.0.0"
-  }
+  },
+  "private": false
 }

package/public/client.js

@@ -1,251 +1,150 @@
-'use strict';
-
-/* globals ajaxify */
+/* eslint-disable no-console */
 (function () {
-  try {
-  if (window.ezoicInfiniteLoaded) return;
-  window.ezoicInfiniteLoaded = true;
-
-  let cachedConfig;
-  let lastFetch = 0;
-  let debounceTimer;
-
-  let inFlight = false;
-  let rerunRequested = false;
-
-  // per page state
-  let pageKey = null;
-
-  // separate pools/state
-  let usedBetween = new Set();  // between topics list
-  let usedMessage = new Set();  // between replies
-  let fifoBetween = [];
-  let fifoMessage = [];
-    // reset serialized showAds queues
-    try {
-      if (typeof queues !== 'undefined') { queues.between.length = 0; queues.message.length = 0; }
-      if (typeof queueState !== 'undefined') { queueState.between = false; queueState.message = false; }
-    } catch (e) {}
-
-  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 isTopicPage() {
-    try {
-      const ax = window.ajaxify;
-      return !!(ax && ax.data && ax.data.tid);
-    } catch (e) {}
-    return /^\/topic\//.test(window.location.pathname);
-  }
-
-  function isCategoryTopicList() {
-    return document.querySelectorAll('li[component="category/topic"]').length > 0 && !isTopicPage();
-  }
-
+  'use strict';
+
+  // NodeBB client env provides jQuery. We keep it optional.
+  const $w = (typeof window.jQuery === 'function') ? window.jQuery(window) : null;
+
+  const SELECTORS = {
+    topicListItem: 'li[component="category/topic"]',
+    postItem: '[component="post"][data-pid]',
+    postContent: '[component="post/content"]',
+  };
+
+  const WRAP_CLASS = 'ezoic-ad';
+  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
+
+  const state = {
+    pageKey: null,
+    cfg: null,
+    cfgPromise: null,
+    // pools and used ids
+    usedBetween: new Set(),
+    usedMessage: new Set(),
+    fifoBetween: [],
+    fifoMessage: [],
+    // showAds anti-double
+    lastShowById: {},
+    pendingById: {},
+    // retry bookkeeping
+    retryCount: {},
+    observers: {},
+  };
 
   function normalizeBool(v) {
-    return v === true || v === 1 || v === '1' || v === 'on' || v === 'true' || v === 'yes';
-  }
-
-  function normalizeInterval(v, fallback) {
-    const n = parseInt(v, 10);
-    return Number.isFinite(n) && n > 0 ? n : fallback;
-  }
-
-  function getPoolValue(v) {
-    // Accept string, array of numbers/strings
-    if (Array.isArray(v)) return v.join('\n');
-    return v;
+    return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
   function parsePool(raw) {
-    raw = getPoolValue(raw);
-
-    raw = getPoolValue(raw);
-
     if (!raw) return [];
-    // accept newline, comma, space, semicolon
-    const arr = String(raw).split(/[\n,;\s]+/)
-      .map(x => parseInt(x, 10))
-      .filter(n => Number.isFinite(n) && n > 0);
-    // unique while preserving order
-    return Array.from(new Set(arr));
-  }
+    const lines = String(raw)
+      .split(/\r?\n/)
+      .map(s => s.trim())
+      .filter(Boolean);
 
-  async function fetchConfig() {
-    if (cachedConfig && Date.now() - lastFetch < 10000) return cachedConfig;
-    const base = (window.config && window.config.relative_path) ? window.config.relative_path : '';
-    const res = await fetch(base + '/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
-    const json = await res.json();
-    cachedConfig = json;
-    lastFetch = Date.now();
-    return json;
-  }
+    const ids = lines
+      .map(s => parseInt(s, 10))
+      .filter(n => Number.isFinite(n) && n > 0);
 
-  function cleanupForNewPage() {
-    document.querySelectorAll('.ezoic-ad').forEach(el => el.remove());
-    usedBetween = new Set();
-    usedMessage = new Set();
-    fifoBetween = [];
-    fifoMessage = [];
-    // reset serialized showAds queues
-    try {
-      if (typeof queues !== 'undefined') { queues.between.length = 0; queues.message.length = 0; }
-      if (typeof queueState !== 'undefined') { queueState.between = false; queueState.message = false; }
-    } catch (e) {}
+    // unique preserve order
+    const out = [];
+    const seen = new Set();
+    for (const id of ids) {
+      if (!seen.has(id)) { seen.add(id); out.push(id); }
+    }
+    return out;
   }
 
-  function destroyPlaceholder(id) {
+  function getPageKey() {
     try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      if (typeof window.ezstandalone.destroyPlaceholders === 'function') {
-        window.ezstandalone.destroyPlaceholders(id);
-        return;
+      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}`;
       }
-      window.ezstandalone.cmd.push(function () {
-        try { window.ezstandalone.destroyPlaceholders(id); } catch (e) {}
-      });
     } catch (e) {}
+    return window.location.pathname;
   }
 
-  function ensureUniquePlaceholder(id) {
-    const existing = document.getElementById('ezoic-pub-ad-placeholder-' + id);
-    if (!existing) return;
-    const wrap = existing.closest('.ezoic-ad');
-    if (wrap) wrap.remove();
-    else existing.remove();
-    destroyPlaceholder(id);
+  function getPageKind() {
+    const p = window.location.pathname || '';
+    if (/^\/topic\//.test(p)) return 'topic';
+    if (/^\/category\//.test(p)) return 'category';
+    // fallback hints
+    if (document.querySelector(SELECTORS.postItem)) return 'topic';
+    if (document.querySelector(SELECTORS.topicListItem)) return 'category';
+    return 'category';
   }
 
-  // Ensure placeholders are filled in the same order they were inserted.
-  // Ezoic can fill asynchronously; we serialize showAds calls per page-type queue.
-  const queues = { between: [], message: [] };
-  const queueState = { between: false, message: false };
-
-  function isFilled(placeholderEl) {
-    if (!placeholderEl) return false;
-    if (placeholderEl.children && placeholderEl.children.length) return true;
-    const html = placeholderEl.innerHTML || '';
-    if (html.trim().length > 0) return true;
-    const r = placeholderEl.getBoundingClientRect ? placeholderEl.getBoundingClientRect() : null;
-    if (r && r.height > 10) return true;
-    return false;
+  function safeGetRect(el) {
+    try { return el.getBoundingClientRect(); } catch (e) { return null; }
   }
 
-  function waitForFilled(placeholderEl, timeoutMs) {
-    return new Promise((resolve) => {
-      if (!placeholderEl) return resolve(false);
-      if (isFilled(placeholderEl)) return resolve(true);
-
-      let done = false;
-      const finish = (ok) => {
-        if (done) return;
-        done = true;
-        try { obs.disconnect(); } catch (e) {}
-        resolve(ok);
-      };
-
-      const obs = new MutationObserver(() => {
-        if (isFilled(placeholderEl)) finish(true);
-      });
-
-      try {
-        obs.observe(placeholderEl, { childList: true, subtree: true, attributes: true });
-      } catch (e) {}
-
-      setTimeout(() => finish(isFilled(placeholderEl)), timeoutMs);
-    });
+  function hasAdImmediatelyAfter(targetEl) {
+    if (!targetEl) return false;
+    const next = targetEl.nextElementSibling;
+    return !!(next && next.classList && next.classList.contains(WRAP_CLASS));
   }
 
-  async function processQueue(kind) {
-    if (queueState[kind]) return;
-    queueState[kind] = true;
-
-    try {
-      while (queues[kind].length) {
-        const item = queues[kind][0];
-        const wrap = item.wrapper;
-        const id = item.id;
-
-        // if removed (recycled) before fill, drop it
-        if (!wrap || !wrap.isConnected) {
-          queues[kind].shift();
-          continue;
-        }
-
-        // call showAds once
-        callShowAdsSingle(id);
+  function buildWrap(id, kind, afterPos) {
+    const wrap = document.createElement('div');
+    wrap.className = `${WRAP_CLASS} ${kind}`;
+    wrap.setAttribute('data-ezoic-after', String(afterPos));
+    wrap.setAttribute('data-ezoic-kind', kind);
+    wrap.style.width = '100%';
 
-        // wait for fill (or timeout) then proceed
-        const ph = document.getElementById('ezoic-pub-ad-placeholder-' + id);
-        await waitForFilled(ph, 5000);
+    const ph = document.createElement('div');
+    ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+    wrap.appendChild(ph);
 
-        queues[kind].shift();
-      }
-    } finally {
-      queueState[kind] = false;
-    }
+    return wrap;
   }
 
-  function enqueueShowAds(kind, wrapperEl, id) {
-    if (!wrapperEl || !id) return;
-    if (wrapperEl.getAttribute('data-ezoic-shown') === '1') return;
-    wrapperEl.setAttribute('data-ezoic-shown', '1');
-    queues[kind].push({ wrapper: wrapperEl, id });
-    processQueue(kind);
+  function insertAfter(targetEl, id, kind, afterPos) {
+    if (!targetEl || !targetEl.insertAdjacentElement) return null;
+    const wrap = buildWrap(id, kind, afterPos);
+    targetEl.insertAdjacentElement('afterend', wrap);
+    return wrap;
   }
 
-  function showAdsOnceForElement(wrapperEl, id) {
-    if (!wrapperEl || !id) return;
-    if (wrapperEl.getAttribute('data-ezoic-shown') === '1') return;
-    wrapperEl.setAttribute('data-ezoic-shown', '1');
-    callShowAdsSingle(id);
+  function destroyPlaceholder(id) {
+    try {
+      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
+        window.ezstandalone.destroyPlaceholders([id]);
+      }
+    } catch (e) {}
   }
 
   function callShowAdsSingle(id) {
     if (!id) return;
-
-    // Normalize id key
     const key = String(id);
 
-    // Ensure we never call showAds twice for the same id within a short window
     const now = Date.now();
-    window.__ezoicLastSingle = window.__ezoicLastSingle || {};
-    const last = window.__ezoicLastSingle[key] || 0;
+    const last = state.lastShowById[key] || 0;
     if (now - last < 4000) return;
 
-    // If showAds is ready now, call once and exit (no cmd + no retry)
+    // If showAds is ready, call once and return
     try {
       window.ezstandalone = window.ezstandalone || {};
       if (typeof window.ezstandalone.showAds === 'function') {
-        window.__ezoicLastSingle[key] = now;
+        state.lastShowById[key] = now;
         window.ezstandalone.showAds(id);
         return;
       }
     } catch (e) {}
 
-    // Otherwise: schedule a single pending call via cmd + retries until it succeeds
-    window.__ezoicPending = window.__ezoicPending || {};
-    if (window.__ezoicPending[key]) return;
-    window.__ezoicPending[key] = true;
+    // Otherwise, queue a single pending attempt (per id)
+    if (state.pendingById[key]) return;
+    state.pendingById[key] = true;
 
     window.ezstandalone = window.ezstandalone || {};
     window.ezstandalone.cmd = window.ezstandalone.cmd || [];
 
-    const tryRun = function () {
+    const tryRun = () => {
       try {
         if (typeof window.ezstandalone.showAds === 'function') {
-          window.__ezoicLastSingle[key] = Date.now();
-          delete window.__ezoicPending[key];
+          state.lastShowById[key] = Date.now();
+          delete state.pendingById[key];
           window.ezstandalone.showAds(id);
           return true;
         }
@@ -253,272 +152,277 @@
       return false;
     };
 
-    // When Ezoic finishes loading, it will drain cmd; run once there
-    window.ezstandalone.cmd.push(function () { tryRun(); });
+    window.ezstandalone.cmd.push(() => { tryRun(); });
 
-    // Retry a few times in case cmd doesn't fire (race conditions)
     let tries = 0;
     (function tick() {
-      tries++;
+      tries += 1;
       if (tryRun() || tries >= 8) {
-        if (tries >= 8) delete window.__ezoicPending[key];
+        if (tries >= 8) delete state.pendingById[key];
         return;
       }
       setTimeout(tick, 800);
     })();
   }
 
-  function pickNextId(pool, usedSet) {
-    for (const id of pool) if (!usedSet.has(id)) return id;
-    return null;
-  }
-
-  function recycle(fifo, usedSet, selector) {
-    // Recycle only ads that are safely outside the viewport (to avoid ads “disappearing” while reading)
-    const margin = 1200; // px
+  function recycleIfNeeded(pool, usedSet, fifo, selectorFn) {
+    // only recycle ads far above the viewport, so they don't "disappear" while reading
+    const margin = 1200;
     const vpTop = -margin;
 
     fifo.sort((a, b) => a.after - b.after);
 
-    // Prefer recycling ads far ABOVE the current viewport (user has already passed them)
     for (let i = 0; i < fifo.length; i++) {
       const old = fifo[i];
-      const el = document.querySelector(selector(old));
+      const el = document.querySelector(selectorFn(old));
       if (!el) {
-        fifo.splice(i, 1);
-        i--;
+        fifo.splice(i, 1); i--;
         continue;
       }
-      const r = el.getBoundingClientRect();
-      if (r.bottom < vpTop) {
+      const r = safeGetRect(el);
+      if (r && r.bottom < vpTop) {
         fifo.splice(i, 1);
         el.remove();
         usedSet.delete(old.id);
         destroyPlaceholder(old.id);
-        return old.id;
+        pool.push(old.id);
+        return true;
       }
     }
+    return false;
+  }
 
-    // If nothing is safely above, do NOT recycle.
+  function nextId(pool, usedSet, fifo, selectorFn) {
+    if (pool.length) return pool.shift();
+    // try recycling one and then use
+    const recycled = recycleIfNeeded(pool, usedSet, fifo, selectorFn);
+    if (recycled && pool.length) return pool.shift();
     return null;
   }
 
-  function insertAfter(targetEl, id, cls, afterVal) {
-    ensureUniquePlaceholder(id);
-    const wrap = document.createElement('div');
-    wrap.className = 'ezoic-ad ' + cls;
-    wrap.setAttribute('data-ezoic-id', String(id));
-    wrap.setAttribute('data-ezoic-after', String(afterVal));
-    wrap.innerHTML = '<div class="ezoic-ad-inner"><div id="ezoic-pub-ad-placeholder-' + id + '"></div></div>';
-    targetEl.insertAdjacentElement('afterend', wrap);
-    return wrap;
+  function getTopicItems() {
+    return Array.from(document.querySelectorAll(SELECTORS.topicListItem));
   }
 
-  function injectBetweenTopics(cfg) {
-    if (!normalizeBool(cfg.enableBetweenAds)) return;
-    const interval = normalizeInterval(cfg.intervalPosts ?? cfg.intervalTopics, 6);
-    const pool = parsePool(cfg.placeholderIds);
-    if (!pool.length) return;
-
-    const items = Array.from(document.querySelectorAll('li[component="category/topic"]'));
-    if (!items.length) return;
-
-    items.forEach((li, idx) => {
-      const pos = idx + 1;
-      const firstEnabled = normalizeBool(cfg.showFirstTopicAd);
-      if (!(firstEnabled && pos === 1) && (pos % interval !== 0)) return;
-      if (idx === items.length - 1) return;
-
-      const next = li.nextElementSibling;
-      if (next && next.classList && next.classList.contains('ezoic-ad-between')) return;
-
-      let id = pickNextId(pool, usedBetween);
-      if (!id) {
-        id = recycle(fifoBetween, usedBetween, (old) => '.ezoic-ad-between[data-ezoic-id="' + old.id + '"][data-ezoic-after="' + old.after + '"]');
-        if (!id) return; // pool empty and nothing recyclable => stop
-      }
-
-      usedBetween.add(id);
-      fifoBetween.push({ id, after: pos });
-
-      const wrap = insertAfter(li, id, 'ezoic-ad-between', pos);
-      enqueueShowAds('between', wrap, id);
-    });
+  function getPostItems() {
+    // NodeBB harmony: component=post with data-pid is stable
+    return Array.from(document.querySelectorAll(SELECTORS.postItem));
   }
 
-  function injectBetweenMessages(cfg) {
-    if (!normalizeBool(cfg.enableMessageAds)) return;
-    const interval = normalizeInterval(cfg.messageIntervalPosts, 3);
-    const pool = parsePool(cfg.messagePlaceholderIds);
-    if (!pool.length) return;
+  function cleanupForNewPage() {
+    state.pageKey = getPageKey();
+    state.cfg = null;
+    state.cfgPromise = null;
 
-    const posts = Array.from(document.querySelectorAll('[component="post"][data-pid]'));
-    if (!posts.length) return;
+    state.usedBetween.clear();
+    state.usedMessage.clear();
+    state.fifoBetween = [];
+    state.fifoMessage = [];
 
-    posts.forEach((post, idx) => {
-      const no = idx + 1;
-      const firstEnabled = normalizeBool(cfg.showFirstMessageAd);
-      if (!(firstEnabled && no === 1) && (no % interval !== 0)) return;
-      if (idx === posts.length - 1) return;
+    state.lastShowById = {};
+    state.pendingById = {};
 
-      const next = post.nextElementSibling;
-      if (next && next.classList && next.classList.contains('ezoic-ad-message')) return;
-
-      let id = pickNextId(pool, usedMessage);
-      if (!id) {
-        id = recycle(fifoMessage, usedMessage, (old) => '.ezoic-ad-message[data-ezoic-id="' + old.id + '"][data-ezoic-after="' + old.after + '"]');
-        if (!id) return;
-      }
+    // Remove injected wrappers
+    document.querySelectorAll(`.${WRAP_CLASS}`).forEach(el => el.remove());
 
-      usedMessage.add(id);
-      fifoMessage.push({ id, after: no });
+    // Disconnect observers
+    Object.values(state.observers).forEach(obs => { try { obs.disconnect(); } catch (e) {} });
+    state.observers = {};
 
-      const wrap = insertAfter(post, id, 'ezoic-ad-message', no);
-      enqueueShowAds('between', wrap, id);
-    });
+    state.retryCount = {};
   }
 
+  async function fetchConfig() {
+    if (state.cfg) return state.cfg;
+    if (state.cfgPromise) return state.cfgPromise;
 
-  function getTopicListItemsFast() {
-    return document.querySelectorAll('li[component="category/topic"]').length;
-  }
+    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;
+      }
+    })();
 
-  function getPostItemsFast() {
-    return document.querySelectorAll('[component="post"][data-pid]').length;
+    return state.cfgPromise;
   }
 
-  function observeUntilTargets(pageType, cb) {
-    // pageType: 'topic' or 'category'
-    const key = pageType + ':' + getPageKey();
-    window.__ezoicObs = window.__ezoicObs || {};
-    if (window.__ezoicObs[key]) return;
+  function observeUntilTargets(kind, cb) {
+    const key = `${kind}:${getPageKey()}`;
+    if (state.observers[key]) return;
 
-    const check = function () {
-      if (pageType === 'topic') return getPostItemsFast() > 0;
-      return getTopicListItemsFast() > 0;
+    const hasTargets = () => {
+      if (kind === 'topic') return document.querySelectorAll(SELECTORS.postItem).length > 0;
+      return document.querySelectorAll(SELECTORS.topicListItem).length > 0;
     };
 
-    if (check()) {
+    if (hasTargets()) {
       cb();
       return;
     }
 
-    const obs = new MutationObserver(function () {
-      if (check()) {
+    const obs = new MutationObserver(() => {
+      if (hasTargets()) {
         try { obs.disconnect(); } catch (e) {}
-        delete window.__ezoicObs[key];
+        delete state.observers[key];
         cb();
       }
     });
 
-    window.__ezoicObs[key] = obs;
+    state.observers[key] = obs;
     try {
       obs.observe(document.body, { childList: true, subtree: true });
-    } catch (e) {
-      // ignore
-    }
+    } catch (e) {}
 
-    // hard stop after 6s
-    setTimeout(function () {
+    setTimeout(() => {
       try { obs.disconnect(); } catch (e) {}
-      delete window.__ezoicObs[key];
+      delete state.observers[key];
     }, 6000);
   }
 
-  function scheduleRetry(flagKey) {
-    window.__ezoicRetry = window.__ezoicRetry || {};
-    window.__ezoicRetry[flagKey] = window.__ezoicRetry[flagKey] || 0;
-    if (window.__ezoicRetry[flagKey] >= 24) return;
-    window.__ezoicRetry[flagKey]++;
+  function scheduleRetry(kind) {
+    const key = `${kind}:${getPageKey()}`;
+    state.retryCount[key] = state.retryCount[key] || 0;
+    if (state.retryCount[key] >= 24) return;
+    state.retryCount[key] += 1;
     setTimeout(run, 250);
   }
 
-  async function run() {
-    if (inFlight) { rerunRequested = true; return; }
-    inFlight = true;
+  function injectBetweenTopics(cfg) {
+    if (!normalizeBool(cfg.enableBetweenAds)) return;
 
-    try {
-      const key = getPageKey();
-      if (pageKey !== key) {
-        pageKey = key;
-        cleanupForNewPage();
-        window.__ezoicCatRetry = 0;
-      }
+    const interval = Math.max(1, parseInt(cfg.intervalPosts, 10) || 6);
+    const firstEnabled = normalizeBool(cfg.showFirstTopicAd);
+
+    const pool = parsePool(cfg.placeholderIds);
+    if (!pool.length) return;
+
+    const items = getTopicItems();
+    if (!items.length) return;
+
+    for (let idx = 0; idx < items.length; idx++) {
+      const li = items[idx];
+      const pos = idx + 1;
 
+      if (!li || !li.isConnected) continue;
+
+      // position rule
+      const ok = (firstEnabled && pos === 1) || (pos % interval === 0);
+      if (!ok) continue;
+
+      if (hasAdImmediatelyAfter(li)) continue;
+
+      const id = nextId(pool, state.usedBetween, state.fifoBetween, (old) => `.${WRAP_CLASS}.ezoic-ad-between[data-ezoic-after="${old.after}"]`);
+      if (!id) break;
+
+      state.usedBetween.add(id);
+      const wrap = insertAfter(li, id, 'ezoic-ad-between', pos);
+      if (!wrap) continue;
+
+      state.fifoBetween.push({ id, after: pos });
+
+      callShowAdsSingle(id);
+    }
+  }
+
+  function injectBetweenMessages(cfg) {
+    if (!normalizeBool(cfg.enableMessageAds)) return;
+
+    const interval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
+    const firstEnabled = normalizeBool(cfg.showFirstMessageAd);
+
+    const pool = parsePool(cfg.messagePlaceholderIds);
+    if (!pool.length) return;
+
+    const posts = getPostItems();
+    if (!posts.length) return;
+
+    for (let idx = 0; idx < posts.length; idx++) {
+      const post = posts[idx];
+      const no = idx + 1;
+      if (!post || !post.isConnected) continue;
+
+      const ok = (firstEnabled && no === 1) || (no % interval === 0);
+      if (!ok) continue;
+
+      if (hasAdImmediatelyAfter(post)) continue;
+
+      const id = nextId(pool, state.usedMessage, state.fifoMessage, (old) => `.${WRAP_CLASS}.ezoic-ad-message[data-ezoic-after="${old.after}"]`);
+      if (!id) break;
+
+      state.usedMessage.add(id);
+      const wrap = insertAfter(post, id, 'ezoic-ad-message', no);
+      if (!wrap) continue;
+
+      state.fifoMessage.push({ id, after: no });
+
+      callShowAdsSingle(id);
+    }
+  }
+
+  async function run() {
+    try {
       const cfg = await fetchConfig();
       if (!cfg || cfg.excluded) return;
 
-      
-      if (isTopicPage()) {
-        const hasPosts = getPostItemsFast() > 0;
-        if (hasPosts) {
-          injectBetweenMessages(cfg);
-        } else {
-          observeUntilTargets('topic', function () { run(); });
-          scheduleRetry('topic:' + getPageKey());
-        }
+      const kind = getPageKind();
+
+      if (kind === 'topic') {
+        const hasPosts = document.querySelectorAll(SELECTORS.postItem).length > 0;
+        if (hasPosts) injectBetweenMessages(cfg);
+        else { observeUntilTargets('topic', run); scheduleRetry('topic'); }
       } else {
-        const hasList = getTopicListItemsFast() > 0;
-        if (hasList) {
-          injectBetweenTopics(cfg);
-        } else {
-          observeUntilTargets('category', function () { run(); });
-          scheduleRetry('category:' + getPageKey());
-        }
+        const hasList = document.querySelectorAll(SELECTORS.topicListItem).length > 0;
+        if (hasList) injectBetweenTopics(cfg);
+        else { observeUntilTargets('category', run); scheduleRetry('category'); }
       }
     } catch (e) {
-      // silent
-    } finally {
-      inFlight = false;
-      if (rerunRequested) {
-        rerunRequested = false;
-        setTimeout(run, 50);
-      }
+      // Never break NodeBB UI
     }
   }
 
-  function scheduleRun() {
-    clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(run, 150);
-  }
+  function bindNodeBBEvents() {
+    if (!$w) return;
 
-function bindNodeBBEvents() {
-    // NodeBB triggers these events through jQuery on window
-    if (window.jQuery) {
-      const $w = window.jQuery(window);
-      $w.off('.ezoicInfinite');
-      $w.on('action:ajaxify.end.ezoicInfinite', function(){ scheduleRun(); setTimeout(scheduleRun, 600); });
-      $w.on('action:posts.loaded.ezoicInfinite', scheduleRun);
-      $w.on('action:topic.loaded.ezoicInfinite', scheduleRun);
-      $w.on('action:topics.loaded.ezoicInfinite', scheduleRun);
-      $w.on('action:category.loaded.ezoicInfinite', scheduleRun);
-      $w.on('action:ajaxify.start.ezoicInfinite', function () {
-        pageKey = null;
-        cleanupForNewPage();
-        window.__ezoicCatRetry = 0;
-      });
-    }
-  }
+    // Prevent duplicate binding
+    $w.off('.ezoicInfinite');
 
-  bindNodeBBEvents();
+    $w.on('action:ajaxify.start.ezoicInfinite', () => {
+      cleanupForNewPage();
+    });
 
-  // Run immediately, so it works on first ajaxify navigation too
-  run();
-  setTimeout(function(){
-    // only retry if nothing was injected yet
-    if (!document.querySelector('.ezoic-ad')) run();
-  }, 1400);
-
-  // Also run on hard-refresh initial load
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', function () {
-      bindNodeBBEvents();
+    $w.on('action:ajaxify.end.ezoicInfinite', () => {
       run();
-      setTimeout(run, 1200);
+      setTimeout(run, 200);
+      setTimeout(run, 800);
     });
+
+    $w.on('action:category.loaded.ezoicInfinite', () => {
+      run();
+      setTimeout(run, 300);
+    });
+
+    $w.on('action:topic.loaded.ezoicInfinite', () => {
+      run();
+      setTimeout(run, 300);
+    });
+
+    // Infinite scroll events (varies by route)
+    $w.on('action:topics.loaded.ezoicInfinite', run);
+    $w.on('action:posts.loaded.ezoicInfinite', run);
   }
-;
-  } catch (e) {
-    // fail silently to avoid breaking NodeBB
-  }
+
+  // Boot
+  cleanupForNewPage();
+  bindNodeBBEvents();
+
+  // First load (non-ajaxify)
+  run();
+  setTimeout(run, 250);
 })();