nodebb-plugin-ezoic-infinite 1.1.6 → 1.2.3

package/package.json

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

package/public/client.js

@@ -2,93 +2,77 @@
 (function () {
   'use strict';
 
-  // NodeBB client env provides jQuery. We keep it optional.
-  const $w = (typeof window.jQuery === 'function') ? window.jQuery(window) : null;
+  // Optional debug switch
+  const DEBUG = !!window.__ezoicInfiniteDebug;
+
+  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
 
   const SELECTORS = {
-    topicListItem: 'li[component="category/topic"]',
+    topicItem: '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-';
 
+  // Prevent “burst” injection: at most N inserts per run per kind
+  const MAX_INSERTS_PER_RUN = 2;
+
   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 patchShowAds() {
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      const ez = window.ezstandalone;
-      if (ez.__nodebbEzoicPatched) return;
-      if (typeof ez.showAds !== 'function') return;
+    // Per-page pools (refilled by recycling)
+    poolTopics: [],
+    poolPosts: [],
 
-      ez.__nodebbEzoicPatched = true;
-      const orig = ez.showAds;
+    // Track inserted ads per page
+    usedTopics: new Set(),
+    usedPosts: new Set(),
 
-      ez.showAds = function showAdsPatched(arg) {
-        if (Array.isArray(arg)) {
-          // This batch call is NOT coming from this plugin (we never call showAds with arrays).
-          // Split into individual calls to avoid Ezoic loadMore/placeholder issues.
-          try {
-            if (window.__ezoicInfiniteDebug) {
-              console.warn('[ezoic-infinite] showAds(batch) detected. Source stack:', new Error().stack);
-            }
-          } catch (e) {}
+    // Track which anchors we already evaluated to avoid reprocessing everything on each event
+    seenTopicAnchors: new WeakSet(),
+    seenPostAnchors: new WeakSet(),
 
-          const seen = new Set();
-          for (const v of arg) {
-            const id = parseInt(v, 10);
-            if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-            seen.add(id);
-            try { orig.call(ez, id); } catch (e) {}
-          }
-          return;
-        }
-        return orig.apply(ez, arguments);
-      };
-    } catch (e) {}
-  }
+    // showAds anti-double
+    lastShowById: new Map(),
+    pendingById: new Set(),
+
+    // debounce
+    scheduled: false,
+    timer: null,
+
+    // observers
+    obs: null,
+  };
+
+  function log(...args) { if (DEBUG) console.log('[ezoic-infinite]', ...args); }
+  function warn(...args) { if (DEBUG) console.warn('[ezoic-infinite]', ...args); }
 
   function normalizeBool(v) {
     return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
-  function parsePool(raw) {
-    if (!raw) return [];
-    const lines = String(raw)
-      .split(/\r?\n/)
-      .map(s => s.trim())
-      .filter(Boolean);
-
-    const ids = lines
-      .map(s => parseInt(s, 10))
-      .filter(n => Number.isFinite(n) && n > 0);
-
-    // unique preserve order
+  function uniqInts(lines) {
     const out = [];
     const seen = new Set();
-    for (const id of ids) {
-      if (!seen.has(id)) { seen.add(id); out.push(id); }
+    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);
+      }
     }
     return out;
   }
 
+  function parsePool(raw) {
+    if (!raw) return [];
+    const lines = String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+    return uniqInts(lines);
+  }
+
   function getPageKey() {
     try {
       const ax = window.ajaxify;
@@ -100,65 +84,83 @@
     return window.location.pathname;
   }
 
-  function getPageKind() {
+  function getKind() {
     const p = window.location.pathname || '';
     if (/^\/topic\//.test(p)) return 'topic';
     if (/^\/category\//.test(p)) return 'category';
-    // fallback hints
+    // fallback
     if (document.querySelector(SELECTORS.postItem)) return 'topic';
-    if (document.querySelector(SELECTORS.topicListItem)) return 'category';
     return 'category';
   }
 
-  function safeGetRect(el) {
-    try { return el.getBoundingClientRect(); } catch (e) { return null; }
-  }
-
-  function hasAdImmediatelyAfter(targetEl) {
-    if (!targetEl) return false;
-    const next = targetEl.nextElementSibling;
-    return !!(next && next.classList && next.classList.contains(WRAP_CLASS));
+  function hasAdImmediatelyAfter(el) {
+    const n = el && el.nextElementSibling;
+    return !!(n && n.classList && n.classList.contains(WRAP_CLASS));
   }
 
   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%';
-
     const ph = document.createElement('div');
     ph.id = `${PLACEHOLDER_PREFIX}${id}`;
     wrap.appendChild(ph);
-
     return wrap;
   }
 
-  function insertAfter(targetEl, id, kind, afterPos) {
-    if (!targetEl || !targetEl.insertAdjacentElement) return null;
+  function insertAfter(target, id, kind, afterPos) {
+    if (!target || !target.insertAdjacentElement) return null;
     const wrap = buildWrap(id, kind, afterPos);
-    targetEl.insertAdjacentElement('afterend', wrap);
+    target.insertAdjacentElement('afterend', wrap);
     return wrap;
   }
 
-  function destroyPlaceholder(id) {
+  function safeRect(el) {
+    try { return el.getBoundingClientRect(); } catch (e) { return null; }
+  }
+    } catch (e) {}
+  }
+
+  // Patch ezstandalone.showAds to split batch calls (we NEVER call batch from this plugin)
+  function patchShowAds() {
     try {
-      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
-        window.ezstandalone.destroyPlaceholders([id]);
-      }
+      window.ezstandalone = window.ezstandalone || {};
+      const ez = window.ezstandalone;
+      if (ez.__nodebbEzoicPatched) return;
+      if (typeof ez.showAds !== 'function') return;
+
+      ez.__nodebbEzoicPatched = true;
+      const orig = ez.showAds;
+
+      ez.showAds = function patchedShowAds(arg) {
+        if (Array.isArray(arg)) {
+          try { warn('showAds(batch) detected. Splitting…'); } catch (e) {}
+          const ids = uniqInts(arg);
+          for (const id of ids) {
+            try { orig.call(ez, id); } catch (e) {}
+          }
+          return;
+        }
+        return orig.apply(ez, arguments);
+      };
     } catch (e) {}
   }
 
-  function callShowAdsSingle(id) {
+  function callShowAdsWhenReady(id) {
     if (!id) return;
-    const key = String(id);
-    const placeholderId = `${PLACEHOLDER_PREFIX}${id}`;
+
+    const now = Date.now();
+    const last = state.lastShowById.get(id) || 0;
+    if (now - last < 3500) return;
+
+    const phId = `${PLACEHOLDER_PREFIX}${id}`;
 
     const doCall = () => {
       try {
         window.ezstandalone = window.ezstandalone || {};
         if (typeof window.ezstandalone.showAds === 'function') {
-          state.lastShowById[key] = Date.now();
+          state.lastShowById.set(id, Date.now());
           window.ezstandalone.showAds(id);
           return true;
         }
@@ -166,122 +168,52 @@
       return false;
     };
 
-    // Wait until the placeholder exists in the DOM (critical on ajaxify navigation)
     let attempts = 0;
-    (function waitForDom() {
+    (function waitForPh() {
       attempts += 1;
-
-      const el = document.getElementById(placeholderId);
+      const el = document.getElementById(phId);
       if (el && el.isConnected) {
-        const now = Date.now();
-        const last = state.lastShowById[key] || 0;
-        if (now - last < 4000) return;
-
         if (doCall()) return;
 
-        // showAds not ready: queue once per id
-        if (state.pendingById[key]) return;
-        state.pendingById[key] = true;
+        if (state.pendingById.has(id)) return;
+        state.pendingById.add(id);
 
         window.ezstandalone = window.ezstandalone || {};
         window.ezstandalone.cmd = window.ezstandalone.cmd || [];
         window.ezstandalone.cmd.push(() => {
           try {
             if (typeof window.ezstandalone.showAds === 'function') {
-              delete state.pendingById[key];
-              state.lastShowById[key] = Date.now();
+              state.pendingById.delete(id);
+              state.lastShowById.set(id, Date.now());
               window.ezstandalone.showAds(id);
             }
           } catch (e) {}
         });
 
-        // also retry a few times in case cmd is late
+        // short retries
         let tries = 0;
         (function tick() {
           tries += 1;
-          if (doCall() || tries >= 6) {
-            if (tries >= 6) delete state.pendingById[key];
+          if (doCall() || tries >= 5) {
+            if (tries >= 5) state.pendingById.delete(id);
             return;
           }
-          setTimeout(tick, 800);
+          setTimeout(tick, 700);
         })();
-
         return;
       }
 
-      if (attempts < 40) { // ~2s
-        setTimeout(waitForDom, 50);
-      }
+      if (attempts < 40) setTimeout(waitForPh, 50);
     })();
   }
-
-
-  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);
-
-    for (let i = 0; i < fifo.length; i++) {
-      const old = fifo[i];
-      const el = document.querySelector(selectorFn(old));
-      if (!el) {
-        fifo.splice(i, 1); i--;
-        continue;
-      }
-      const r = safeGetRect(el);
-      if (r && r.bottom < vpTop) {
-        fifo.splice(i, 1);
-        el.remove();
-        usedSet.delete(old.id);
-        destroyPlaceholder(old.id);
-        pool.push(old.id);
-        return true;
-      }
     }
     return false;
   }
 
-  function nextId(pool, usedSet, fifo, selectorFn) {
+  function nextId(kind) {
+    const pool = (kind === 'between') ? state.poolTopics : state.poolPosts;
     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 getTopicItems() {
-    return Array.from(document.querySelectorAll(SELECTORS.topicListItem));
-  }
-
-  function getPostItems() {
-    // NodeBB harmony: component=post with data-pid is stable
-    return Array.from(document.querySelectorAll(SELECTORS.postItem));
-  }
-
-  function cleanupForNewPage() {
-    state.pageKey = getPageKey();
-    state.cfg = null;
-    state.cfgPromise = null;
-
-    state.usedBetween.clear();
-    state.usedMessage.clear();
-    state.fifoBetween = [];
-    state.fifoMessage = [];
-
-    state.lastShowById = {};
-    state.pendingById = {};
-
-    // Remove injected wrappers
-    document.querySelectorAll(`.${WRAP_CLASS}`).forEach(el => el.remove());
-
-    // Disconnect observers
-    Object.values(state.observers).forEach(obs => { try { obs.disconnect(); } catch (e) {} });
-    state.observers = {};
-
-    state.retryCount = {};
-
+    return null; // stop injecting when pool is empty
   }
 
   async function fetchConfig() {
@@ -292,9 +224,8 @@
       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;
+        state.cfg = await res.json();
+        return state.cfg;
       } catch (e) {
         return null;
       } finally {
@@ -305,259 +236,202 @@
     return state.cfgPromise;
   }
 
-  function observeUntilTargets(kind, cb) {
-    const key = `${kind}:${getPageKey()}`;
-    if (state.observers[key]) return;
-
-    const hasTargets = () => {
-      if (kind === 'topic') return document.querySelectorAll(SELECTORS.postItem).length > 0;
-      return document.querySelectorAll(SELECTORS.topicListItem).length > 0;
-    };
-
-    if (hasTargets()) {
-      cb();
-      return;
-    }
-
-    const obs = new MutationObserver(() => {
-      if (hasTargets()) {
-        try { obs.disconnect(); } catch (e) {}
-        delete state.observers[key];
-        cb();
-      }
-    });
-
-    state.observers[key] = obs;
-    try {
-      obs.observe(document.body, { childList: true, subtree: true });
-    } catch (e) {}
-
-    setTimeout(() => {
-      try { obs.disconnect(); } catch (e) {}
-      delete state.observers[key];
-    }, 15000);
+  function initPools(cfg) {
+    // Re-init pools once per page
+    if (state.poolTopics.length === 0) state.poolTopics = parsePool(cfg.placeholderIds);
+    if (state.poolPosts.length === 0) state.poolPosts = parsePool(cfg.messagePlaceholderIds);
   }
 
-  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);
-  }
-        } catch (e) {}
-      };
-
-      state.predeclared[kind].add(key);
-
-      if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') {
-        call();
-        return;
-      }
-
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      window.ezstandalone.cmd.push(call);
-    } catch (e) {}
-  }
-
-  function injectBetweenTopics(cfg) {
-    if (!normalizeBool(cfg.enableBetweenAds)) return;
+  function injectTopics(cfg) {
+    if (!normalizeBool(cfg.enableBetweenAds)) return 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 first = normalizeBool(cfg.showFirstTopicAd);
 
-    const items = getTopicItems();
-    if (!items.length) return;
-
-    for (let idx = 0; idx < items.length; idx++) {
-      const li = items[idx];
-      const pos = idx + 1;
+    const items = Array.from(document.querySelectorAll(SELECTORS.topicItem));
+    if (!items.length) return 0;
 
+    let inserted = 0;
+    for (let i = 0; i < items.length; i++) {
+      const li = items[i];
       if (!li || !li.isConnected) continue;
 
-      // position rule
-      const ok = (firstEnabled && pos === 1) || (pos % interval === 0);
+      // Avoid re-processing anchors already evaluated
+      if (state.seenTopicAnchors.has(li)) continue;
+
+      const pos = i + 1;
+      const ok = (first && pos === 1) || (pos % interval === 0);
+      state.seenTopicAnchors.add(li);
       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}"]`);
+      const id = nextId('between');
       if (!id) break;
 
-      state.usedBetween.add(id);
+      state.usedTopics.add(id);
       const wrap = insertAfter(li, id, 'ezoic-ad-between', pos);
       if (!wrap) continue;
 
-      state.fifoBetween.push({ id, after: pos });
+      inserted += 1;
+
+      callShowAdsWhenReady(id);
 
-      callShowAdsSingle(id);
+      if (inserted >= MAX_INSERTS_PER_RUN) break;
     }
+    return inserted;
   }
 
-  function injectBetweenMessages(cfg) {
-    if (!normalizeBool(cfg.enableMessageAds)) return;
+  function injectPosts(cfg) {
+    if (!normalizeBool(cfg.enableMessageAds)) return 0;
 
     const interval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
-    const firstEnabled = normalizeBool(cfg.showFirstMessageAd);
+    const first = normalizeBool(cfg.showFirstMessageAd);
 
-    const pool = parsePool(cfg.messagePlaceholderIds);
-    if (!pool.length) return;
+    const posts = Array.from(document.querySelectorAll(SELECTORS.postItem));
+    if (!posts.length) return 0;
 
-    const posts = getPostItems();
-    if (!posts.length) return;
-
-    for (let idx = 0; idx < posts.length; idx++) {
-      const post = posts[idx];
-      const no = idx + 1;
+    let inserted = 0;
+    for (let i = 0; i < posts.length; i++) {
+      const post = posts[i];
       if (!post || !post.isConnected) continue;
 
-      const ok = (firstEnabled && no === 1) || (no % interval === 0);
+      if (state.seenPostAnchors.has(post)) continue;
+
+      const no = i + 1;
+      const ok = (first && no === 1) || (no % interval === 0);
+      state.seenPostAnchors.add(post);
       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}"]`);
+      const id = nextId('message');
       if (!id) break;
 
-      state.usedMessage.add(id);
+      state.usedPosts.add(id);
       const wrap = insertAfter(post, id, 'ezoic-ad-message', no);
       if (!wrap) continue;
 
-      state.fifoMessage.push({ id, after: no });
+      inserted += 1;
 
-      callShowAdsSingle(id);
+      callShowAdsWhenReady(id);
+
+      if (inserted >= MAX_INSERTS_PER_RUN) break;
     }
+    return inserted;
   }
 
-  let scheduled = false;
-  let scheduledTimer = null;
-
-  function scheduleRun(reason) {
-    if (scheduled) return;
-    scheduled = true;
-
-    const startKey = getPageKey();
-
-    const settleAndRun = () => {
-      // If page changed, reschedule for new page
-      if (getPageKey() !== startKey) { scheduled = false; scheduleRun('page-changed'); return; }
-
-      // Wait until the relevant DOM count is stable for a short window
-      const kind = getPageKind();
-      const sel = (kind === 'topic') ? SELECTORS.postItem : SELECTORS.topicListItem;
+  function cleanup() {
+    state.pageKey = getPageKey();
+    state.cfg = null;
+    state.cfgPromise = null;
 
-      let lastCount = document.querySelectorAll(sel).length;
-      let stableTicks = 0;
+    state.poolTopics = [];
+    state.poolPosts = [];
+    state.usedTopics.clear();
+    state.usedPosts.clear();
 
-      const step = () => {
-        if (getPageKey() !== startKey) { scheduled = false; scheduleRun('page-changed'); return; }
+    state.seenTopicAnchors = new WeakSet();
+    state.seenPostAnchors = new WeakSet();
 
-        const c = document.querySelectorAll(sel).length;
-        if (c === lastCount && c > 0) stableTicks += 1;
-        else { stableTicks = 0; lastCount = c; }
+    state.lastShowById = new Map();
+    state.pendingById = new Set();
 
-        if (stableTicks >= 2) { // ~2 frames stable
-          scheduled = false;
-          run();
-          return;
-        }
-        requestAnimationFrame(step);
-      };
-
-      requestAnimationFrame(step);
-    };
+    document.querySelectorAll(`.${WRAP_CLASS}`).forEach(el => el.remove());
 
-    // small delay to coalesce multiple NodeBB events
-    clearTimeout(scheduledTimer);
-    scheduledTimer = setTimeout(settleAndRun, 60);
+    if (state.obs) { try { state.obs.disconnect(); } catch (e) {} state.obs = null; }
+    state.scheduled = false;
+    clearTimeout(state.timer);
+    state.timer = null;
   }
 
-  function runAfterPaint() {
-    // Ensure we run after the browser has painted the newly inserted DOM (Harmony/category topics list can be late)
-    requestAnimationFrame(() => {
-      requestAnimationFrame(() => {
-        run();
-      });
-    });
+  function ensureObserver() {
+    if (state.obs) return;
+    state.obs = new MutationObserver(() => scheduleRun('dom-mutation'));
+    try { state.obs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
+    setTimeout(() => { if (state.obs) { try { state.obs.disconnect(); } catch (e) {} state.obs = null; } }, 12000);
   }
 
-  async function run() {
-    try {
-      const cfg = await fetchConfig();
-      if (!cfg || cfg.excluded) return;
+  async function runCore() {
+    patchShowAds();
 
-      // If Ezoic is not ready yet, schedule a single rerun via ezstandalone.cmd
-      try {
-        window.ezstandalone = window.ezstandalone || {};
-        window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-        if (typeof window.ezstandalone.showAds !== 'function') {
-          const rk = 'ezoicReadyRerun:' + getPageKey();
-          if (!state.retryCount[rk]) {
-            state.retryCount[rk] = 1;
-            window.ezstandalone.cmd.push(() => { setTimeout(run, 0); });
-          }
-        }
-      } catch (e) {}
+    const cfg = await fetchConfig();
+    if (!cfg || cfg.excluded) return;
 
-      const kind = getPageKind();
+    initPools(cfg);
 
-      if (kind === 'topic') {
-        const hasPosts = document.querySelectorAll(SELECTORS.postItem).length > 0;
-        if (hasPosts) { injectBetweenMessages(cfg); }
-        else { observeUntilTargets('topic', run); scheduleRetry('topic'); }
-      } else {
-        const hasList = document.querySelectorAll(SELECTORS.topicListItem).length > 0;
-        if (hasList) { injectBetweenTopics(cfg); }
-        else { observeUntilTargets('category', run); scheduleRetry('category'); }
-      }
-    } catch (e) {
-      // Never break NodeBB UI
+    const kind = getKind();
+    let inserted = 0;
+
+    if (kind === 'topic') inserted = injectPosts(cfg);
+    else inserted = injectTopics(cfg);
+
+    // If we inserted max per run, schedule another pass to gradually fill (avoids “burst”)
+    if (inserted >= MAX_INSERTS_PER_RUN) {
+      setTimeout(() => scheduleRun('continue-fill'), 120);
     }
   }
 
-  function bindNodeBBEvents() {
-    if (!$w) return;
+  function scheduleRun(reason) {
+    if (state.scheduled) return;
+    state.scheduled = true;
+
+    clearTimeout(state.timer);
+    state.timer = setTimeout(() => {
+      state.scheduled = false;
+      // Ensure we're still on same page
+      const pk = getPageKey();
+      if (state.pageKey && pk !== state.pageKey) return;
+      runCore().catch(() => {});
+    }, 80);
+
+  function bind() {
+    if (!$) return;
 
-    // Prevent duplicate binding
-    $w.off('.ezoicInfinite');
+    $(window).off('.ezoicInfinite');
 
-    $w.on('action:ajaxify.start.ezoicInfinite', () => {
-      cleanupForNewPage();
+    $(window).on('action:ajaxify.start.ezoicInfinite', () => {
+      cleanup();
     });
 
-    $w.on('action:ajaxify.end.ezoicInfinite', () => {
-      patchShowAds();
+    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
+      state.pageKey = getPageKey();
+      ensureObserver();
       scheduleRun('ajaxify.end');
       setTimeout(() => scheduleRun('ajaxify.end+250'), 250);
-      setTimeout(() => scheduleRun('ajaxify.end+900'), 900);
+      setTimeout(() => scheduleRun('ajaxify.end+800'), 800);
     });
 
-    $w.on('action:category.loaded.ezoicInfinite', () => {
+    $(window).on('action:category.loaded.ezoicInfinite', () => {
+      ensureObserver();
       scheduleRun('category.loaded');
-      setTimeout(() => scheduleRun('category.loaded+200'), 200);
-      setTimeout(() => scheduleRun('category.loaded+700'), 700);
+      setTimeout(() => scheduleRun('category.loaded+250'), 250);
     });
 
-    $w.on('action:topic.loaded.ezoicInfinite', () => {
+    $(window).on('action:topics.loaded.ezoicInfinite', () => {
+      ensureObserver();
+      scheduleRun('topics.loaded');
+      setTimeout(() => scheduleRun('topics.loaded+150'), 150);
+    });
+
+    $(window).on('action:topic.loaded.ezoicInfinite', () => {
+      ensureObserver();
       scheduleRun('topic.loaded');
-      setTimeout(() => scheduleRun('topic.loaded+300'), 300);
+      setTimeout(() => scheduleRun('topic.loaded+200'), 200);
     });
 
-    // Infinite scroll events (varies by route)
-    $w.on('action:topics.loaded.ezoicInfinite', () => { runAfterPaint(); setTimeout(run, 150); setTimeout(run, 600); });
-    $w.on('action:posts.loaded.ezoicInfinite', () => { scheduleRun('posts.loaded'); setTimeout(() => scheduleRun('posts.loaded+250'), 250); });
+    $(window).on('action:posts.loaded.ezoicInfinite', () => {
+      ensureObserver();
+      scheduleRun('posts.loaded');
+      setTimeout(() => scheduleRun('posts.loaded+150'), 150);
+    });
   }
 
   // Boot
-  patchShowAds();
-  cleanupForNewPage();
-  bindNodeBBEvents();
-
-  // First load (non-ajaxify)
-  scheduleRun('first-load');
-  setTimeout(() => scheduleRun('first-load+250'), 250);
+  cleanup();
+  bind();
+  ensureObserver();
+  state.pageKey = getPageKey();
+  scheduleRun('boot');
+  setTimeout(() => scheduleRun('boot+250'), 250);
 })();