npm - nodebb-plugin-ezoic-infinite - Versions diffs - 1.8.38 → 1.8.40 - Mend

nodebb-plugin-ezoic-infinite 1.8.38 → 1.8.40

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/package.json +1 -1
package/public/client.js +318 -535

package/package.json CHANGED Viewed

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

package/public/client.js CHANGED Viewed

@@ -1,13 +1,15 @@
 /**
- * NodeBB Ezoic Infinite Ads — client.js v2.1.0
+ * NodeBB Ezoic Infinite Ads — client.js v3.0.0
  *
- * Fixes in v2.1:
- * - Early bail when user is excluded (no ezstandalone reference errors)
- * - aria-hidden on <body>: MutationObserver removes it continuously
- * - Recycle threshold raised to -3×vh to prevent mobile fast-scroll blank ads
- * - Scroll-up: re-observe placeholders whose wraps come back into DOM
- * - adsbygoogle "already have ads" error: clear ins before recycle
- * - TCF/CMP 3-layer protection (head iframe, API guard, MutationObserver)
+ * Proper Ezoic infinite scroll API flow:
+ *
+ *   FIRST BATCH:   ez.define(ids...)  → ez.enable()
+ *   NEXT BATCHES:  ez.define(ids...)  → ez.displayMore(ids...)
+ *   RECYCLE:        ez.destroyPlaceholders(id) → new placeholder DOM
+ *                   → ez.define(id)  → ez.displayMore(id)
+ *
+ * phState machine per placeholder ID:
+ *   new → defined → displayed → [destroyed → new]  (recycle loop)
  */
 (function nbbEzoicInfinite() {
   'use strict';
@@ -30,16 +32,13 @@
     SHOW_THROTTLE_MS:     900,
     BURST_COOLDOWN_MS:    200,
     BLOCK_DURATION_MS:  1_500,
-    SHOW_TIMEOUT_MS:    7_000,
-    SHOW_RELEASE_MS:      700,
-    BATCH_FLUSH_MS:        80,
-    RECYCLE_DELAY_MS:     450,
+    BATCH_FLUSH_MS:       120,
+    RECYCLE_DESTROY_MS:   300,
+    RECYCLE_DEFINE_MS:    300,
   };
   const LIMITS = {
     MAX_INSERTS_RUN: 6,
-    MAX_INFLIGHT:    4,
-    BATCH_SIZE:      3,
     MAX_BURST_STEPS: 8,
     BURST_WINDOW_MS: 2_000,
   };
@@ -63,30 +62,25 @@
   const FILL_SEL = 'iframe, ins, img, video, [data-google-container-id], div[id$="__container__"]';
+  const RECYCLE_MIN_AGE_MS = 5_000;
   // ── Utility ────────────────────────────────────────────────────────────────
   const now      = () => Date.now();
   const isMobile = () => window.innerWidth < 768;
   const normBool = v  => v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
-  function isFilled(node) {
-    return node?.querySelector?.(FILL_SEL) != null;
-  }
+  function isFilled(node)        { return node?.querySelector?.(FILL_SEL) != null; }
   function isPlaceholderUsed(ph) {
     if (!ph?.isConnected) return false;
     return ph.querySelector('ins.adsbygoogle, iframe, [data-google-container-id], div[id$="__container__"]') != null;
   }
   function parseIds(raw) {
-    const out = [];
-    const seen = new Set();
+    const out = [], seen = new Set();
     for (const line of String(raw || '').split(/[\r\n,\s]+/)) {
       const n = parseInt(line, 10);
-      if (n > 0 && Number.isFinite(n) && !seen.has(n)) {
-        seen.add(n);
-        out.push(n);
-      }
+      if (n > 0 && Number.isFinite(n) && !seen.has(n)) { seen.add(n); out.push(n); }
     }
     return out;
   }
@@ -94,37 +88,29 @@
   // ── State ──────────────────────────────────────────────────────────────────
   const state = {
-    pageKey:    null,
-    kind:       null,
-    cfg:        null,
+    pageKey: null, kind: null, cfg: null,
     poolsReady: false,
-    pools:      { topics: [], posts: [], categories: [] },
-    cursors:    { topics: 0,  posts: 0,  categories: 0  },
-    mountedIds: new Set(),
-    phState:    new Map(),
-    lastShow:   new Map(),
+    pools:   { topics: [], posts: [], categories: [] },
+    cursors: { topics: 0,  posts: 0,  categories: 0  },
+    mountedIds:   new Set(),
+    // phState: 'new' | 'defined' | 'displayed' | 'destroyed'
+    phState:      new Map(),
+    lastShow:     new Map(),
     wrapByKey:    new Map(),
     wrapsByClass: new Map(),
-    io:     null,
-    domObs: null,
+    io: null, domObs: null,
+    mutGuard: 0, blockedUntil: 0,
-    mutGuard:     0,
-    blockedUntil: 0,
+    // Ezoic batch queue: ids waiting for define+displayMore
+    ezBatch:      new Set(),
+    ezFlushTimer: null,
-    inflight:   0,
-    pending:    [],
-    pendingSet: new Set(),
-    runQueued:     false,
-    burstActive:   false,
-    burstDeadline: 0,
-    burstCount:    0,
-    lastBurstTs:   0,
-    firstShown:    false,
+    // Lifecycle
+    runQueued:    false,
+    burstActive:  false, burstDeadline: 0, burstCount: 0, lastBurstTs: 0,
   };
   const isBlocked = () => now() < state.blockedUntil;
@@ -140,10 +126,7 @@
     if (state.cfg) return state.cfg;
     try {
       const inline = window.__nbbEzoicCfg;
-      if (inline && typeof inline === 'object') {
-        state.cfg = inline;
-        return state.cfg;
-      }
+      if (inline && typeof inline === 'object') { state.cfg = inline; return state.cfg; }
     } catch (_) {}
     try {
       const r = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
@@ -182,15 +165,12 @@
     return 'other';
   }
-  function getKind() {
-    return state.kind || (state.kind = detectKind());
-  }
+  function getKind() { return state.kind || (state.kind = detectKind()); }
   // ── DOM queries ────────────────────────────────────────────────────────────
   function getPosts() {
-    const all = document.querySelectorAll(SEL.post);
-    const out = [];
+    const all = document.querySelectorAll(SEL.post), out = [];
     for (let i = 0; i < all.length; i++) {
       const el = all[i];
       if (!el.isConnected) continue;
@@ -202,7 +182,6 @@
     }
     return out;
   }
   function getTopics()     { return Array.from(document.querySelectorAll(SEL.topic)); }
   function getCategories() { return Array.from(document.querySelectorAll(SEL.category)); }
@@ -210,15 +189,10 @@
   function stableId(klass, el) {
     const attr = KIND[klass]?.anchorAttr;
-    if (attr) {
-      const v = el.getAttribute(attr);
-      if (v != null && v !== '') return v;
-    }
+    if (attr) { const v = el.getAttribute(attr); if (v != null && v !== '') return v; }
     const children = el.parentElement?.children;
     if (!children) return 'i0';
-    for (let i = 0; i < children.length; i++) {
-      if (children[i] === el) return `i${i}`;
-    }
+    for (let i = 0; i < children.length; i++) { if (children[i] === el) return `i${i}`; }
     return 'i0';
   }
@@ -230,9 +204,9 @@
   }
   function getWrapSet(klass) {
-    let set = state.wrapsByClass.get(klass);
-    if (!set) { set = new Set(); state.wrapsByClass.set(klass, set); }
-    return set;
+    let s = state.wrapsByClass.get(klass);
+    if (!s) { s = new Set(); state.wrapsByClass.set(klass, s); }
+    return s;
   }
   // ── Wrap lifecycle ─────────────────────────────────────────────────────────
@@ -241,28 +215,19 @@
     if (!wrap?.classList?.contains(WRAP_CLASS)) return false;
     const key = wrap.getAttribute(ATTR.ANCHOR);
     if (!key) return false;
     if (state.wrapByKey.get(key) === wrap) return wrap.isConnected;
     const colonIdx = key.indexOf(':');
-    const klass    = key.slice(0, colonIdx);
-    const anchorId = key.slice(colonIdx + 1);
+    const klass = key.slice(0, colonIdx), anchorId = key.slice(colonIdx + 1);
     const cfg = KIND[klass];
     if (!cfg) return false;
     const parent = wrap.parentElement;
     if (parent) {
       const sel = `${cfg.baseTag || ''}[${cfg.anchorAttr}="${anchorId}"]`;
       for (const sib of parent.children) {
-        if (sib !== wrap) {
-          try { if (sib.matches(sel)) return sib.isConnected; } catch (_) {}
-        }
+        if (sib !== wrap) { try { if (sib.matches(sel)) return sib.isConnected; } catch (_) {} }
       }
     }
-    try {
-      return document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`)?.isConnected === true;
-    } catch (_) { return false; }
+    try { return document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`)?.isConnected === true; } catch (_) { return false; }
   }
   function adjacentWrap(el) {
@@ -277,20 +242,18 @@
     if (!ph || !isFilled(ph)) return false;
     wrap.classList.remove('is-empty');
     const id = parseInt(wrap.getAttribute(ATTR.WRAPID) || '0', 10);
-    if (id > 0) state.phState.set(id, 'shown');
+    if (id > 0) state.phState.set(id, 'displayed');
     return true;
   }
   function scheduleUncollapseChecks(wrap) {
     if (!wrap) return;
     for (const ms of [500, 1500, 3000, 7000, 15000]) {
-      setTimeout(() => {
-        try { clearEmptyIfFilled(wrap); } catch (_) {}
-      }, ms);
+      setTimeout(() => { try { clearEmptyIfFilled(wrap); } catch (_) {} }, ms);
     }
   }
-  // ── Pool management ────────────────────────────────────────────────────────
+  // ── Pool ───────────────────────────────────────────────────────────────────
   function pickId(poolKey) {
     const pool = state.pools[poolKey];
@@ -304,17 +267,152 @@
     return null;
   }
-  // ── Recycling ──────────────────────────────────────────────────────────────
+  // ── Ezoic API layer ────────────────────────────────────────────────────────
+  //
+  // Correct Ezoic infinite scroll flow:
+  //   First batch:  ez.cmd.push(() => { ez.define(...ids); ez.enable(); })
+  //   Next batches: ez.cmd.push(() => { ez.define(...ids); ez.displayMore(...ids); })
+  //   Recycle:      ez.cmd.push(() => { ez.destroyPlaceholders(id); })
+  //                 → wait → new DOM → ez.cmd.push(() => { ez.define(id); ez.displayMore(id); })
   //
-  // v2.1 changes:
-  // - Threshold raised to -(3 × vh) — on mobile fast scroll, -vh was too close
-  //   and wraps got recycled before ads had time to load
-  // - Never recycle a wrap whose showAds is still inflight (show-queued state)
-  // - Clear ins.adsbygoogle children before re-creating placeholder to avoid
-  //   "All ins elements already have ads" error
-  // - Skip wraps that were created less than 5s ago (give ads time to fill)
+  // We batch define+displayMore calls using ezBatch to avoid calling the
+  // Ezoic API on every single placeholder insertion.
-  const RECYCLE_MIN_AGE_MS = 5_000;
+  function ezCmd(fn) {
+    window.ezstandalone = window.ezstandalone || {};
+    const ez = window.ezstandalone;
+    if (Array.isArray(ez.cmd)) {
+      ez.cmd.push(fn);
+    } else {
+      try { fn(); } catch (_) {}
+    }
+  }
+  /**
+   * Queue a placeholder ID for the next batched define+displayMore call.
+   */
+  function ezEnqueue(id) {
+    if (isBlocked()) return;
+    state.ezBatch.add(id);
+    if (!state.ezFlushTimer) {
+      state.ezFlushTimer = setTimeout(ezFlush, TIMING.BATCH_FLUSH_MS);
+    }
+  }
+  /**
+   * Flush: define new IDs with Ezoic, then call displayMore.
+   *
+   * IMPORTANT: We NEVER call ez.enable() — Ezoic's sa.min.js calls it
+   * automatically on page load. Calling it again causes
+   * "Enable should only ever be called once" error.
+   *
+   * We also check ez.getSelectedPlaceholders() or equivalent to skip
+   * IDs that Ezoic already knows about (defined during initial enable).
+   */
+  function ezFlush() {
+    state.ezFlushTimer = null;
+    if (isBlocked() || !state.ezBatch.size) return;
+    // Filter to only valid, connected placeholders
+    const ids = [];
+    for (const id of state.ezBatch) {
+      const ph = document.getElementById(`${PH_PREFIX}${id}`);
+      if (!ph?.isConnected) { state.phState.delete(id); continue; }
+      if (isPlaceholderUsed(ph)) { state.phState.set(id, 'displayed'); continue; }
+      ids.push(id);
+    }
+    state.ezBatch.clear();
+    if (!ids.length) return;
+    ezCmd(() => {
+      const ez = window.ezstandalone;
+      if (!ez) return;
+      // Check which IDs Ezoic already knows about to avoid "already defined"
+      const alreadyDefined = new Set();
+      try {
+        // ez.allPlaceholders is an array of IDs Ezoic has already seen
+        if (Array.isArray(ez.allPlaceholders)) {
+          for (const p of ez.allPlaceholders) alreadyDefined.add(Number(p));
+        }
+      } catch (_) {}
+      const toDefine = ids.filter(id => !alreadyDefined.has(id));
+      // All IDs get displayMore, but only new ones get define
+      const toDisplay = ids;
+      // define() only for truly new placeholders
+      if (toDefine.length) {
+        try {
+          if (typeof ez.define === 'function') {
+            ez.define(...toDefine);
+          }
+        } catch (_) {}
+      }
+      for (const id of ids) state.phState.set(id, 'defined');
+      // displayMore() for all IDs — this is the infinite scroll API
+      if (toDisplay.length) {
+        try {
+          if (typeof ez.displayMore === 'function') {
+            ez.displayMore(...toDisplay);
+          }
+        } catch (_) {}
+      }
+      // Mark as displayed and schedule fill checks
+      for (const id of ids) {
+        state.phState.set(id, 'displayed');
+        state.lastShow.set(id, now());
+        const ph = document.getElementById(`${PH_PREFIX}${id}`);
+        const wrap = ph?.closest(`.${WRAP_CLASS}`);
+        if (wrap) {
+          wrap.setAttribute(ATTR.SHOWN, String(now()));
+          scheduleUncollapseChecks(wrap);
+        }
+        scheduleEmptyCheck(id);
+      }
+    });
+  }
+  /**
+   * Destroy a placeholder in Ezoic (for recycling).
+   * Returns a Promise that resolves after the destroy delay.
+   */
+  function ezDestroy(id) {
+    return new Promise(resolve => {
+      ezCmd(() => {
+        state.phState.set(id, 'destroyed');
+        const ez = window.ezstandalone;
+        try {
+          if (typeof ez?.destroyPlaceholders === 'function') {
+            ez.destroyPlaceholders(id);
+          }
+        } catch (_) {}
+        setTimeout(resolve, TIMING.RECYCLE_DESTROY_MS);
+      });
+    });
+  }
+  function scheduleEmptyCheck(id) {
+    const showTs = now();
+    setTimeout(() => {
+      try {
+        const ph   = document.getElementById(`${PH_PREFIX}${id}`);
+        const wrap = ph?.closest(`.${WRAP_CLASS}`);
+        if (!wrap || !ph?.isConnected) return;
+        if (parseInt(wrap.getAttribute(ATTR.SHOWN) || '0', 10) > showTs) return;
+        if (clearEmptyIfFilled(wrap)) return;
+        wrap.classList.add('is-empty');
+      } catch (_) {}
+    }, TIMING.EMPTY_CHECK_MS);
+  }
+  // ── Recycling ──────────────────────────────────────────────────────────────
+  //
+  // When pool is exhausted, find the farthest wrap above viewport,
+  // destroy its Ezoic placeholder, recreate the DOM, then define+displayMore.
   function recycleWrap(klass, targetEl, newKey) {
     const ez = window.ezstandalone;
@@ -323,7 +421,6 @@
         typeof ez?.displayMore        !== 'function') return null;
     const vh = window.innerHeight || 800;
-    // Conservative threshold: 3× viewport height above the top of the screen
     const threshold = -(3 * vh);
     const t = now();
     let bestEmpty = null, bestEmptyY = Infinity;
@@ -334,17 +431,14 @@
     for (const wrap of wraps) {
       try {
-        // Don't recycle wraps that are too young (ads might still be loading)
         const created = parseInt(wrap.getAttribute(ATTR.CREATED) || '0', 10);
         if (t - created < RECYCLE_MIN_AGE_MS) continue;
-        // Don't recycle wraps with inflight showAds
         const wid = parseInt(wrap.getAttribute(ATTR.WRAPID), 10);
-        if (wid > 0 && state.phState.get(wid) === 'show-queued') continue;
+        const st = state.phState.get(wid);
+        // Don't recycle placeholders that are still being processed
+        if (st === 'new' || st === 'defined') continue;
         const bottom = wrap.getBoundingClientRect().bottom;
         if (bottom > threshold) continue;
         if (!isFilled(wrap)) {
           if (bottom < bestEmptyY) { bestEmptyY = bottom; bestEmpty = wrap; }
         } else {
@@ -367,43 +461,40 @@
       if (ph) state.io?.unobserve(ph);
     } catch (_) {}
-    // Move the wrap to new position with a clean placeholder
-    mutate(() => {
-      best.setAttribute(ATTR.ANCHOR,  newKey);
-      best.setAttribute(ATTR.CREATED, String(now()));
-      best.setAttribute(ATTR.SHOWN,   '0');
-      best.classList.remove('is-empty');
-      // Clear ALL children including ins.adsbygoogle to avoid
-      // "All ins elements already have ads" error on re-show
-      best.replaceChildren();
-      const fresh = document.createElement('div');
-      fresh.id = `${PH_PREFIX}${id}`;
-      fresh.setAttribute('data-ezoic-id', String(id));
-      fresh.style.minHeight = '1px';
-      best.appendChild(fresh);
-      targetEl.insertAdjacentElement('afterend', best);
-    });
+    // Step 1: Destroy in Ezoic, then recreate DOM and re-define
+    state.phState.set(id, 'destroyed');
-    if (oldKey && state.wrapByKey.get(oldKey) === best) state.wrapByKey.delete(oldKey);
-    state.wrapByKey.set(newKey, best);
+    ezCmd(() => {
+      try { ez.destroyPlaceholders(id); } catch (_) {}
-    // Ezoic destroy → re-define → re-show sequence
-    const doDestroy = () => {
-      state.phState.set(id, 'destroyed');
-      try { ez.destroyPlaceholders(id); } catch (_) {
-        try { ez.destroyPlaceholders([id]); } catch (_) {}
-      }
       setTimeout(() => {
-        try { observePlaceholder(id); } catch (_) {}
-        state.phState.set(id, 'new');
-        try { enqueueShow(id); } catch (_) {}
-      }, TIMING.RECYCLE_DELAY_MS);
-    };
+        // Step 2: Recreate placeholder DOM at new position
+        mutate(() => {
+          best.setAttribute(ATTR.ANCHOR,  newKey);
+          best.setAttribute(ATTR.CREATED, String(now()));
+          best.setAttribute(ATTR.SHOWN,   '0');
+          best.classList.remove('is-empty');
+          best.replaceChildren();
+          const fresh = document.createElement('div');
+          fresh.id = `${PH_PREFIX}${id}`;
+          fresh.setAttribute('data-ezoic-id', String(id));
+          fresh.style.minHeight = '1px';
+          best.appendChild(fresh);
+          targetEl.insertAdjacentElement('afterend', best);
+        });
-    try {
-      (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doDestroy) : doDestroy();
-    } catch (_) {}
+        if (oldKey && state.wrapByKey.get(oldKey) === best) state.wrapByKey.delete(oldKey);
+        state.wrapByKey.set(newKey, best);
+        // Step 3: Re-define + displayMore via the batch queue
+        setTimeout(() => {
+          state.phState.set(id, 'new');
+          observePlaceholder(id);
+          ezEnqueue(id);
+        }, TIMING.RECYCLE_DEFINE_MS);
+      }, TIMING.RECYCLE_DESTROY_MS);
+    });
     return { id, wrap: best };
   }
@@ -418,7 +509,6 @@
     w.setAttribute(ATTR.CREATED, String(now()));
     w.setAttribute(ATTR.SHOWN,   '0');
     w.style.cssText = 'width:100%;display:block';
     const ph = document.createElement('div');
     ph.id = `${PH_PREFIX}${id}`;
     ph.setAttribute('data-ezoic-id', String(id));
@@ -433,7 +523,6 @@
     if (state.mountedIds.has(id)) return null;
     const existing = document.getElementById(`${PH_PREFIX}${id}`);
     if (existing?.isConnected) return null;
     const w = makeWrap(id, klass, key);
     mutate(() => el.insertAdjacentElement('afterend', w));
     state.mountedIds.add(id);
@@ -447,20 +536,13 @@
     try {
       const ph = w.querySelector(`[id^="${PH_PREFIX}"]`);
       if (ph instanceof Element) state.io?.unobserve(ph);
       const id = parseInt(w.getAttribute(ATTR.WRAPID), 10);
-      if (Number.isFinite(id)) {
-        state.mountedIds.delete(id);
-        state.phState.delete(id);
-      }
+      if (Number.isFinite(id)) { state.mountedIds.delete(id); state.phState.delete(id); }
       const key = w.getAttribute(ATTR.ANCHOR);
       if (key && state.wrapByKey.get(key) === w) state.wrapByKey.delete(key);
       for (const cls of w.classList) {
         if (cls !== WRAP_CLASS && cls.startsWith('ezoic-ad-')) {
-          state.wrapsByClass.get(cls)?.delete(w);
-          break;
+          state.wrapsByClass.get(cls)?.delete(w); break;
         }
       }
       w.remove();
@@ -474,22 +556,18 @@
     const cfg   = KIND[klass];
     const wraps = state.wrapsByClass.get(klass);
     if (!wraps?.size) return;
     const liveAnchors = new Set();
     for (const el of document.querySelectorAll(`${cfg.baseTag}[${cfg.anchorAttr}]`)) {
       const v = el.getAttribute(cfg.anchorAttr);
       if (v) liveAnchors.add(v);
     }
     const t = now();
     for (const w of wraps) {
       const created = parseInt(w.getAttribute(ATTR.CREATED) || '0', 10);
       if (t - created < TIMING.MIN_PRUNE_AGE_MS) continue;
       const key = w.getAttribute(ATTR.ANCHOR) ?? '';
       const sid = key.slice(klass.length + 1);
-      if (!sid || !liveAnchors.has(sid)) {
-        mutate(() => dropWrap(w));
-      }
+      if (!sid || !liveAnchors.has(sid)) mutate(() => dropWrap(w));
     }
   }
@@ -517,11 +595,9 @@
     for (const el of items) {
       if (inserted >= LIMITS.MAX_INSERTS_RUN) break;
       if (!el?.isConnected) continue;
       const ord = ordinal(klass, el);
       if (!(showFirst && ord === 0) && (ord + 1) % interval !== 0) continue;
       if (adjacentWrap(el)) continue;
       const key = anchorKey(klass, el);
       if (findWrap(key)) continue;
@@ -530,7 +606,8 @@
         const w = insertAfter(el, id, klass, key);
         if (w) {
           observePlaceholder(id);
-          if (!state.firstShown) { state.firstShown = true; enqueueShow(id); }
+          // Queue for batched define+enable/displayMore
+          ezEnqueue(id);
           inserted++;
         }
       } else {
@@ -543,6 +620,12 @@
   }
   // ── IntersectionObserver ───────────────────────────────────────────────────
+  //
+  // The IO is used to eagerly observe placeholders so that when they enter
+  // the viewport margin, we can queue them for Ezoic. However, the actual
+  // Ezoic API calls (define/displayMore) happen in the batched flush.
+  // The IO callback is mainly useful for re-triggering after NodeBB
+  // virtualisation re-inserts posts.
   function getIO() {
     if (state.io) return state.io;
@@ -550,12 +633,19 @@
       state.io = new IntersectionObserver(entries => {
         for (const entry of entries) {
           if (!entry.isIntersecting) continue;
-          // DON'T unobserve — we need to re-trigger on scroll-up when NodeBB
-          // re-inserts virtualized posts back into the DOM.
-          // Instead, the show throttle (SHOW_THROTTLE_MS) and phState check
-          // in enqueueShow prevent duplicate calls.
-          const id = parseInt(entry.target.getAttribute('data-ezoic-id'), 10);
-          if (id > 0) enqueueShow(id);
+          const target = entry.target;
+          if (target instanceof Element) state.io?.unobserve(target);
+          const id = parseInt(target.getAttribute('data-ezoic-id'), 10);
+          if (!id || id <= 0) continue;
+          const st = state.phState.get(id);
+          // Only enqueue if not yet processed by Ezoic
+          if (st === 'new') {
+            ezEnqueue(id);
+          } else if (st === 'displayed') {
+            // Already shown — check if the placeholder is actually filled.
+            // If not (Ezoic had no ad), don't re-trigger — it won't help.
+            // If yes, nothing to do.
+          }
         }
       }, {
         root: null,
@@ -568,227 +658,19 @@
   function observePlaceholder(id) {
     const ph = document.getElementById(`${PH_PREFIX}${id}`);
-    if (ph?.isConnected) {
-      try { getIO()?.observe(ph); } catch (_) {}
-    }
-  }
-  // ── Show queue ─────────────────────────────────────────────────────────────
-  function enqueueShow(id) {
-    if (!id || isBlocked()) return;
-    const st = state.phState.get(id);
-    if (st === 'show-queued' || st === 'shown') return;
-    if (now() - (state.lastShow.get(id) ?? 0) < TIMING.SHOW_THROTTLE_MS) return;
-    if (state.inflight >= LIMITS.MAX_INFLIGHT) {
-      if (!state.pendingSet.has(id)) {
-        state.pending.push(id);
-        state.pendingSet.add(id);
-        state.phState.set(id, 'show-queued');
-      }
-      return;
-    }
-    state.phState.set(id, 'show-queued');
-    startShow(id);
-  }
-  function drainQueue() {
-    if (isBlocked()) return;
-    while (state.inflight < LIMITS.MAX_INFLIGHT && state.pending.length) {
-      const id = state.pending.shift();
-      state.pendingSet.delete(id);
-      startShow(id);
-    }
-  }
-  function startShow(id) {
-    if (!id || isBlocked()) return;
-    state.inflight++;
-    let released = false;
-    const release = () => {
-      if (released) return;
-      released = true;
-      state.inflight = Math.max(0, state.inflight - 1);
-      drainQueue();
-    };
-    const timer = setTimeout(release, TIMING.SHOW_TIMEOUT_MS);
-    requestAnimationFrame(() => {
-      try {
-        if (isBlocked()) { clearTimeout(timer); return release(); }
-        const ph = document.getElementById(`${PH_PREFIX}${id}`);
-        if (!ph?.isConnected) {
-          state.phState.delete(id);
-          clearTimeout(timer);
-          return release();
-        }
-        if (isFilled(ph) || isPlaceholderUsed(ph)) {
-          state.phState.set(id, 'shown');
-          clearTimeout(timer);
-          return release();
-        }
-        const t = now();
-        if (t - (state.lastShow.get(id) ?? 0) < TIMING.SHOW_THROTTLE_MS) {
-          clearTimeout(timer);
-          return release();
-        }
-        state.lastShow.set(id, t);
-        try { ph.closest(`.${WRAP_CLASS}`)?.setAttribute(ATTR.SHOWN, String(t)); } catch (_) {}
-        state.phState.set(id, 'shown');
-        window.ezstandalone = window.ezstandalone || {};
-        const ez = window.ezstandalone;
-        const doShow = () => {
-          const wrap = ph.closest(`.${WRAP_CLASS}`);
-          try { ez.showAds(id); } catch (_) {}
-          if (wrap) scheduleUncollapseChecks(wrap);
-          scheduleEmptyCheck(id, t);
-          setTimeout(() => { clearTimeout(timer); release(); }, TIMING.SHOW_RELEASE_MS);
-        };
-        Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
-      } catch (_) {
-        clearTimeout(timer);
-        release();
-      }
-    });
-  }
-  function scheduleEmptyCheck(id, showTs) {
-    setTimeout(() => {
-      try {
-        const ph   = document.getElementById(`${PH_PREFIX}${id}`);
-        const wrap = ph?.closest(`.${WRAP_CLASS}`);
-        if (!wrap || !ph?.isConnected) return;
-        if (parseInt(wrap.getAttribute(ATTR.SHOWN) || '0', 10) > showTs) return;
-        if (clearEmptyIfFilled(wrap)) return;
-        wrap.classList.add('is-empty');
-      } catch (_) {}
-    }, TIMING.EMPTY_CHECK_MS);
-  }
-  // ── Patch Ezoic showAds ────────────────────────────────────────────────────
-  function patchShowAds() {
-    const apply = () => {
-      try {
-        window.ezstandalone = window.ezstandalone || {};
-        const ez = window.ezstandalone;
-        if (window.__nbbEzPatched || typeof ez.showAds !== 'function') return;
-        window.__nbbEzPatched = true;
-        const orig = ez.showAds.bind(ez);
-        const queue = new Set();
-        let flushTimer = null;
-        const flush = () => {
-          flushTimer = null;
-          if (isBlocked() || !queue.size) return;
-          const ids = Array.from(queue).sort((a, b) => a - b);
-          queue.clear();
-          const valid = ids.filter(id => {
-            const ph = document.getElementById(`${PH_PREFIX}${id}`);
-            if (!ph?.isConnected) { state.phState.delete(id); return false; }
-            if (isPlaceholderUsed(ph)) { state.phState.set(id, 'shown'); return false; }
-            return true;
-          });
-          for (let i = 0; i < valid.length; i += LIMITS.BATCH_SIZE) {
-            const chunk = valid.slice(i, i + LIMITS.BATCH_SIZE);
-            try { orig(...chunk); } catch (_) {
-              for (const cid of chunk) { try { orig(cid); } catch (_) {} }
-            }
-          }
-        };
-        ez.showAds = function (...args) {
-          if (isBlocked()) return;
-          const ids = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
-          for (const v of ids) {
-            const id = parseInt(v, 10);
-            if (!Number.isFinite(id) || id <= 0) continue;
-            const ph = document.getElementById(`${PH_PREFIX}${id}`);
-            if (!ph?.isConnected) continue;
-            if (isPlaceholderUsed(ph)) { state.phState.set(id, 'shown'); continue; }
-            state.phState.set(id, 'show-queued');
-            queue.add(id);
-          }
-          if (queue.size && !flushTimer) {
-            flushTimer = setTimeout(flush, TIMING.BATCH_FLUSH_MS);
-          }
-        };
-      } catch (_) {}
-    };
-    apply();
-    if (!window.__nbbEzPatched) {
-      window.ezstandalone = window.ezstandalone || {};
-      (window.ezstandalone.cmd = window.ezstandalone.cmd || []).push(apply);
-    }
-  }
-  // ── Re-observe on scroll-up ────────────────────────────────────────────────
-  //
-  // NodeBB virtualizes posts: removes them from DOM when off-viewport, then
-  // re-inserts them when scrolling back up. Our wraps stay in the DOM but
-  // the placeholder was already unobserved by IO (in v2.0) or the phState
-  // was 'shown'. We need to check if wraps that are back in viewport have
-  // unfilled placeholders and re-trigger show for them.
-  function reobserveVisibleWraps() {
-    const vh = window.innerHeight || 800;
-    for (const [key, wrap] of state.wrapByKey) {
-      if (!wrap.isConnected) continue;
-      const id = parseInt(wrap.getAttribute(ATTR.WRAPID), 10);
-      if (!id || id <= 0) continue;
-      const ph = wrap.querySelector(`[id^="${PH_PREFIX}"]`);
-      if (!ph?.isConnected) continue;
-      // Already filled — nothing to do
-      if (isFilled(ph) || isPlaceholderUsed(ph)) continue;
-      // Check if the wrap is in or near the viewport
-      const rect = wrap.getBoundingClientRect();
-      if (rect.bottom < -vh || rect.top > 2 * vh) continue;
-      // This wrap is visible-ish but unfilled — re-trigger
-      const st = state.phState.get(id);
-      if (st === 'shown' || st === 'show-queued') {
-        // Reset state so enqueueShow accepts it again
-        state.phState.set(id, 'new');
-        state.lastShow.delete(id);
-      }
-      // Re-observe in IO (safe to call multiple times)
-      try { getIO()?.observe(ph); } catch (_) {}
-      enqueueShow(id);
-    }
+    if (ph?.isConnected) { try { getIO()?.observe(ph); } catch (_) {} }
   }
   // ── Core ───────────────────────────────────────────────────────────────────
   async function runCore() {
     if (isBlocked()) return 0;
     const cfg = await fetchConfig();
     if (!cfg || cfg.excluded) return 0;
     initPools(cfg);
     const kind = getKind();
     if (kind === 'other') return 0;
-    // Re-observe wraps that came back into viewport (scroll-up fix)
-    reobserveVisibleWraps();
     const exec = (klass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
       if (!normBool(cfgEnable)) return 0;
       const interval = Math.max(1, parseInt(cfgInterval, 10) || 3);
@@ -796,24 +678,16 @@
     };
     if (kind === 'topic') {
-      return exec(
-        'ezoic-ad-message', getPosts,
-        cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts'
-      );
+      return exec('ezoic-ad-message', getPosts,
+        cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts');
     }
     if (kind === 'categoryTopics') {
       pruneOrphansBetween();
-      return exec(
-        'ezoic-ad-between', getTopics,
-        cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics'
-      );
+      return exec('ezoic-ad-between', getTopics,
+        cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics');
     }
-    return exec(
-      'ezoic-ad-categories', getCategories,
-      cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories'
-    );
+    return exec('ezoic-ad-categories', getCategories,
+      cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories');
   }
   // ── Scheduler & burst ──────────────────────────────────────────────────────
@@ -837,62 +711,55 @@
     state.lastBurstTs   = t;
     state.pageKey       = pageKey();
     state.burstDeadline = t + LIMITS.BURST_WINDOW_MS;
     if (state.burstActive) return;
     state.burstActive = true;
     state.burstCount  = 0;
     const step = () => {
       if (pageKey() !== state.pageKey || isBlocked() || now() > state.burstDeadline || state.burstCount >= LIMITS.MAX_BURST_STEPS) {
-        state.burstActive = false;
-        return;
+        state.burstActive = false; return;
       }
       state.burstCount++;
       scheduleRun(n => {
-        if (!n && !state.pending.length) { state.burstActive = false; return; }
+        if (!n && !state.ezBatch.size) { state.burstActive = false; return; }
         setTimeout(step, n > 0 ? 150 : 300);
       });
     };
     step();
   }
-  // ── Cleanup on navigation ──────────────────────────────────────────────────
+  // ── Cleanup ────────────────────────────────────────────────────────────────
   function cleanup() {
     state.blockedUntil = now() + TIMING.BLOCK_DURATION_MS;
+    // Cancel pending Ezoic batch
+    if (state.ezFlushTimer) { clearTimeout(state.ezFlushTimer); state.ezFlushTimer = null; }
+    state.ezBatch.clear();
     mutate(() => {
-      for (const w of document.querySelectorAll(`.${WRAP_CLASS}`)) {
-        dropWrap(w);
-      }
+      for (const w of document.querySelectorAll(`.${WRAP_CLASS}`)) dropWrap(w);
     });
-    state.cfg          = null;
-    state.poolsReady   = false;
-    state.pools        = { topics: [], posts: [], categories: [] };
-    state.cursors      = { topics: 0, posts: 0, categories: 0 };
+    state.cfg = null;
+    state.poolsReady = false;
+    state.pools   = { topics: [], posts: [], categories: [] };
+    state.cursors = { topics: 0, posts: 0, categories: 0 };
     state.mountedIds.clear();
     state.lastShow.clear();
     state.wrapByKey.clear();
     state.wrapsByClass.clear();
-    state.kind         = null;
+    state.kind = null;
     state.phState.clear();
-    state.inflight     = 0;
-    state.pending      = [];
-    state.pendingSet.clear();
     state.burstActive  = false;
     state.runQueued    = false;
-    state.firstShown   = false;
   }
   // ── MutationObserver ───────────────────────────────────────────────────────
   function ensureDomObserver() {
     if (state.domObs) return;
     state.domObs = new MutationObserver(muts => {
       if (state.mutGuard > 0 || isBlocked()) return;
       let needsBurst = false;
       const kind = getKind();
       const relevantSels =
         kind === 'topic'          ? [SEL.post]     :
@@ -905,7 +772,7 @@
         for (const node of m.addedNodes) {
           if (!(node instanceof Element)) continue;
-          // Check for ad fill events in wraps
+          // Ad fill detection
           try {
             if (node.matches?.(FILL_SEL) || node.querySelector?.(FILL_SEL)) {
               const wrap = node.closest?.(`.${WRAP_CLASS}.is-empty`) ||
@@ -914,140 +781,91 @@
             }
           } catch (_) {}
-          // Check for new content items
+          // Re-observe wraps re-inserted by NodeBB virtualization
+          try {
+            const wraps = node.classList?.contains(WRAP_CLASS)
+              ? [node]
+              : Array.from(node.querySelectorAll?.(`.${WRAP_CLASS}`) || []);
+            for (const wrap of wraps) {
+              const id = parseInt(wrap.getAttribute(ATTR.WRAPID), 10);
+              if (!id || id <= 0) continue;
+              const ph = wrap.querySelector(`[id^="${PH_PREFIX}"]`);
+              if (ph) { try { getIO()?.observe(ph); } catch (_) {} }
+            }
+          } catch (_) {}
+          // New content detection
           if (!needsBurst) {
             for (const sel of relevantSels) {
               try {
-                if (node.matches(sel) || node.querySelector(sel)) {
-                  needsBurst = true;
-                  break;
-                }
+                if (node.matches(sel) || node.querySelector(sel)) { needsBurst = true; break; }
               } catch (_) {}
             }
           }
         }
         if (needsBurst) break;
       }
       if (needsBurst) requestBurst();
     });
-    try {
-      state.domObs.observe(document.body, { childList: true, subtree: true });
-    } catch (_) {}
+    try { state.domObs.observe(document.body, { childList: true, subtree: true }); } catch (_) {}
   }
   // ── TCF / CMP Protection ───────────────────────────────────────────────────
-  //
-  // 3 layers:
-  //  1. PROTECT: locator iframe in <head> (ajaxify never touches <head>)
-  //  2. GUARD: wrap __tcfapi/__cmp to catch null contentWindow errors
-  //  3. RESTORE: MutationObserver for immediate re-creation
   function ensureTcfLocator() {
     if (!window.__tcfapi && !window.__cmp) return;
     const LOCATOR_ID = '__tcfapiLocator';
     const ensureInHead = () => {
       let existing = document.getElementById(LOCATOR_ID);
       if (existing) {
         if (existing.parentElement !== document.head) {
           try { document.head.appendChild(existing); } catch (_) {}
         }
-        return existing;
+        return;
       }
       const f = document.createElement('iframe');
-      f.style.display = 'none';
-      f.id = f.name = LOCATOR_ID;
+      f.style.display = 'none'; f.id = f.name = LOCATOR_ID;
       try { document.head.appendChild(f); } catch (_) {
         (document.body || document.documentElement).appendChild(f);
       }
-      return f;
     };
     ensureInHead();
-    // Guard CMP API calls
     if (!window.__nbbCmpGuarded) {
       window.__nbbCmpGuarded = true;
       if (typeof window.__tcfapi === 'function') {
-        const origTcf = window.__tcfapi;
-        window.__tcfapi = function (cmd, version, cb, param) {
-          try {
-            return origTcf.call(this, cmd, version, function (...args) {
-              try { cb?.(...args); } catch (_) {}
-            }, param);
-          } catch (e) {
-            if (e?.message?.includes('null')) {
-              ensureInHead();
-              try { return origTcf.call(this, cmd, version, cb, param); } catch (_) {}
-            }
-          }
+        const orig = window.__tcfapi;
+        window.__tcfapi = function (cmd, ver, cb, param) {
+          try { return orig.call(this, cmd, ver, function (...a) { try { cb?.(...a); } catch (_) {} }, param); }
+          catch (e) { if (e?.message?.includes('null')) { ensureInHead(); try { return orig.call(this, cmd, ver, cb, param); } catch (_) {} } }
         };
       }
       if (typeof window.__cmp === 'function') {
-        const origCmp = window.__cmp;
-        window.__cmp = function (...args) {
-          try {
-            return origCmp.apply(this, args);
-          } catch (e) {
-            if (e?.message?.includes('null')) {
-              ensureInHead();
-              try { return origCmp.apply(this, args); } catch (_) {}
-            }
-          }
+        const orig = window.__cmp;
+        window.__cmp = function (...a) {
+          try { return orig.apply(this, a); }
+          catch (e) { if (e?.message?.includes('null')) { ensureInHead(); try { return orig.apply(this, a); } catch (_) {} } }
         };
       }
     }
     if (!window.__nbbTcfObs) {
       window.__nbbTcfObs = new MutationObserver(() => {
-        if (document.getElementById(LOCATOR_ID)) return;
-        ensureInHead();
+        if (!document.getElementById(LOCATOR_ID)) ensureInHead();
       });
-      try {
-        window.__nbbTcfObs.observe(document.body || document.documentElement, {
-          childList: true, subtree: false,
-        });
-      } catch (_) {}
-      try {
-        if (document.head) {
-          window.__nbbTcfObs.observe(document.head, {
-            childList: true, subtree: false,
-          });
-        }
-      } catch (_) {}
+      try { window.__nbbTcfObs.observe(document.body || document.documentElement, { childList: true, subtree: false }); } catch (_) {}
+      try { if (document.head) window.__nbbTcfObs.observe(document.head, { childList: true, subtree: false }); } catch (_) {}
     }
   }
   // ── aria-hidden protection ─────────────────────────────────────────────────
-  //
-  // The CMP modal sets aria-hidden="true" on <body> when opening, and may not
-  // remove it after ajaxify navigation. A simple removeAttribute in ajaxify.end
-  // isn't enough because the CMP can re-set it asynchronously.
-  //
-  // Use a MutationObserver on <body> attributes to remove it immediately.
   function protectAriaHidden() {
     if (window.__nbbAriaObs) return;
     const remove = () => {
-      try {
-        if (document.body.getAttribute('aria-hidden') === 'true') {
-          document.body.removeAttribute('aria-hidden');
-        }
-      } catch (_) {}
+      try { if (document.body.getAttribute('aria-hidden') === 'true') document.body.removeAttribute('aria-hidden'); } catch (_) {}
     };
     remove();
     window.__nbbAriaObs = new MutationObserver(remove);
-    try {
-      window.__nbbAriaObs.observe(document.body, {
-        attributes: true,
-        attributeFilter: ['aria-hidden'],
-      });
-    } catch (_) {}
+    try { window.__nbbAriaObs.observe(document.body, { attributes: true, attributeFilter: ['aria-hidden'] }); } catch (_) {}
   }
   // ── Console muting ─────────────────────────────────────────────────────────
@@ -1055,10 +873,8 @@
   function muteConsole() {
     if (window.__nbbEzMuted) return;
     window.__nbbEzMuted = true;
     const PREFIXES = [
       '[EzoicAds JS]: Placeholder Id',
-      'No valid placeholders for loadMore',
       'cannot call refresh on the same page',
       'no placeholders are currently defined in Refresh',
       'Debugger iframe already exists',
@@ -1068,20 +884,18 @@
     const PATTERNS = [
       `with id ${PH_PREFIX}`,
       'adsbygoogle.push() error: All',
+      'has already been defined',
+      'No valid placeholders for loadMore',
+      'bad response. Status',
     ];
     for (const method of ['log', 'info', 'warn', 'error']) {
       const orig = console[method];
       if (typeof orig !== 'function') continue;
       console[method] = function (...args) {
         if (typeof args[0] === 'string') {
           const msg = args[0];
-          for (const prefix of PREFIXES) {
-            if (msg.startsWith(prefix)) return;
-          }
-          for (const pat of PATTERNS) {
-            if (msg.includes(pat)) return;
-          }
+          for (const p of PREFIXES) { if (msg.startsWith(p)) return; }
+          for (const p of PATTERNS) { if (msg.includes(p)) return; }
         }
         return orig.apply(console, args);
       };
@@ -1091,28 +905,22 @@
   // ── Network warmup ─────────────────────────────────────────────────────────
   let _networkWarmed = false;
   function warmNetwork() {
     if (_networkWarmed) return;
     _networkWarmed = true;
     const head = document.head;
     if (!head) return;
-    const hints = [
+    for (const [rel, href, cors] of [
       ['preconnect',   'https://g.ezoic.net',                    true ],
       ['preconnect',   'https://go.ezoic.net',                   true ],
       ['preconnect',   'https://securepubads.g.doubleclick.net', true ],
       ['preconnect',   'https://pagead2.googlesyndication.com',  true ],
       ['dns-prefetch', 'https://g.ezoic.net',                    false],
       ['dns-prefetch', 'https://securepubads.g.doubleclick.net', false],
-    ];
-    for (const [rel, href, cors] of hints) {
+    ]) {
       if (head.querySelector(`link[rel="${rel}"][href="${href}"]`)) continue;
       const link = document.createElement('link');
-      link.rel = rel;
-      link.href = href;
+      link.rel = rel; link.href = href;
       if (cors) link.crossOrigin = 'anonymous';
       head.appendChild(link);
     }
@@ -1123,46 +931,25 @@
   function bindNodeBB() {
     const $ = window.jQuery;
     if (!$) return;
     $(window).off('.nbbEzoic');
     $(window).on('action:ajaxify.start.nbbEzoic', cleanup);
     $(window).on('action:ajaxify.end.nbbEzoic', () => {
-      state.pageKey      = pageKey();
-      state.kind         = null;
+      state.pageKey = pageKey();
+      state.kind = null;
       state.blockedUntil = 0;
-      muteConsole();
-      ensureTcfLocator();
-      protectAriaHidden();
-      warmNetwork();
-      patchShowAds();
-      getIO();
-      ensureDomObserver();
-      requestBurst();
+      muteConsole(); ensureTcfLocator(); protectAriaHidden(); warmNetwork();
+      getIO(); ensureDomObserver(); requestBurst();
     });
     const burstEvents = [
-      'action:ajaxify.contentLoaded',
-      'action:posts.loaded',
-      'action:topics.loaded',
-      'action:categories.loaded',
-      'action:category.loaded',
-      'action:topic.loaded',
+      'action:ajaxify.contentLoaded', 'action:posts.loaded', 'action:topics.loaded',
+      'action:categories.loaded', 'action:category.loaded', 'action:topic.loaded',
     ].map(e => `${e}.nbbEzoic`).join(' ');
     $(window).on(burstEvents, () => { if (!isBlocked()) requestBurst(); });
     try {
       require(['hooks'], hooks => {
         if (typeof hooks?.on !== 'function') return;
-        for (const ev of [
-          'action:ajaxify.end',
-          'action:posts.loaded',
-          'action:topics.loaded',
-          'action:categories.loaded',
-          'action:topic.loaded',
-        ]) {
+        for (const ev of ['action:ajaxify.end', 'action:posts.loaded', 'action:topics.loaded',
+                          'action:categories.loaded', 'action:topic.loaded']) {
           try { hooks.on(ev, () => { if (!isBlocked()) requestBurst(); }); } catch (_) {}
         }
       });
@@ -1174,10 +961,7 @@
     window.addEventListener('scroll', () => {
       if (ticking) return;
       ticking = true;
-      requestAnimationFrame(() => {
-        ticking = false;
-        requestBurst();
-      });
+      requestAnimationFrame(() => { ticking = false; requestBurst(); });
     }, { passive: true });
   }
@@ -1188,7 +972,6 @@
   ensureTcfLocator();
   protectAriaHidden();
   warmNetwork();
-  patchShowAds();
   getIO();
   ensureDomObserver();
   bindNodeBB();