nodebb-plugin-ezoic-infinite 1.8.21 → 1.8.22

package/public/client.js

@@ -1,328 +1,114 @@
-(function nbbEzoicInfinite() {
+(function nbbEzoicInfiniteV22() {
   'use strict';
 
-  // ── Constantes ─────────────────────────────────────────────────────────────
-
-  const WRAP_CLASS  = 'nodebb-ezoic-wrap';
-  const PH_PREFIX   = 'ezoic-pub-ad-placeholder-';
-  const A_ANCHOR    = 'data-ezoic-anchor';   // "kindClass:stableId"
-  const A_WRAPID    = 'data-ezoic-wrapid';   // id Ezoic
-  const A_CREATED   = 'data-ezoic-created';  // timestamp création ms
-  const A_SHOWN     = 'data-ezoic-shown';    // timestamp dernier showAds ms
-
-  // Tunables (stables en prod)
-  const MIN_PRUNE_AGE_MS  = 8_000;   // délai de grâce avant pruning (stabilisation DOM)
-  const MAX_INSERTS_RUN   = 10;      // plus réactif si NodeBB injecte en rafale
-  const MAX_INFLIGHT      = 2;       // ids max simultanés en vol (garde-fou)
-  const MAX_SHOW_BATCH    = 4;       // ids max par appel showAds(...ids)
-  const SHOW_THROTTLE_MS  = 500;     // anti-spam showAds() par id (plus réactif)
-  const SHOW_RELEASE_MS   = 300;     // relâche inflight après showAds() batché
-  const SHOW_FAILSAFE_MS  = 7000;    // relâche forcée si stack pub lente
-  const BATCH_FLUSH_MS    = 30;      // micro-buffer pour regrouper les ids proches
-  const MAX_DESTROY_BATCH  = 4;       // ids max par destroyPlaceholders(...ids)
-  const DESTROY_FLUSH_MS   = 30;      // micro-buffer destroy pour lisser les rafales
-  const BURST_COOLDOWN_MS = 100;     // délai min entre deux déclenchements de burst
-  const CLEANUP_GRACE_MS   = 3_500;   // délai mini avant cleanup d'un wrap candidat
-  const SPECIAL_GRACE_MS   = 30_000;  // délai allongé pour sticky/fixed/adhesion
-  const RECENT_WRAP_ACTIVITY_MS = 5_000; // protège un wrap récemment muté/rafraîchi
-  const VIEWPORT_BUFFER_DESKTOP = 500;
-  const VIEWPORT_BUFFER_MOBILE  = 250;
-
-  // Marges IO larges et fixes — observer créé une seule fois au boot
-  const IO_MARGIN_DESKTOP = '2500px 0px 2500px 0px';
-  const IO_MARGIN_MOBILE  = '3500px 0px 3500px 0px';
+  const WRAP_CLASS = 'nodebb-ezoic-wrap';
+  const PH_PREFIX = 'ezoic-pub-ad-placeholder-';
+  const A_ANCHOR = 'data-ezoic-anchor';
+  const A_WRAPID = 'data-ezoic-wrapid';
+  const A_CREATED = 'data-ezoic-created';
+  const A_SHOWN = 'data-ezoic-shown';
+  const A_STATE = 'data-ezoic-state';
 
   const SEL = {
-    post:     '[component="post"][data-pid]',
-    topic:    'li[component="category/topic"]',
+    post: '[component="post"][data-pid]',
+    topic: 'li[component="category/topic"]',
     category: 'li[component="categories/category"]',
   };
-  const WRAP_SEL = `.${WRAP_CLASS}`;
-  const FILL_SEL = 'iframe, ins, img, video, [data-google-container-id]';
-  const CONTENT_SEL_LIST = [SEL.post, SEL.topic, SEL.category];
 
-  /**
-   * Table KIND — source de vérité par kindClass.
-   *
-   * sel         sélecteur CSS complet des éléments cibles
-   * baseTag     préfixe tag pour querySelector d'ancre
-   *             (vide pour posts : le sélecteur commence par '[')
-   * anchorAttr  attribut DOM stable → clé unique du wrap
-   * ordinalAttr attribut 0-based pour le calcul de l'intervalle
-   *             null → fallback positionnel (catégories)
-   */
   const KIND = {
-    'ezoic-ad-message':    { sel: SEL.post,     baseTag: '',   anchorAttr: 'data-pid',   ordinalAttr: 'data-index' },
-    'ezoic-ad-between':    { sel: SEL.topic,    baseTag: 'li', anchorAttr: 'data-index', ordinalAttr: 'data-index' },
-    'ezoic-ad-categories': { sel: SEL.category, baseTag: 'li', anchorAttr: 'data-cid',   ordinalAttr: null         },
+    'ezoic-ad-message':    { sel: SEL.post,     baseTag: '',   anchorAttr: 'data-pid',   ordinalAttr: 'data-index', pool: 'posts' },
+    'ezoic-ad-between':    { sel: SEL.topic,    baseTag: 'li', anchorAttr: 'data-index', ordinalAttr: 'data-index', pool: 'topics' },
+    'ezoic-ad-categories': { sel: SEL.category, baseTag: 'li', anchorAttr: 'data-cid',   ordinalAttr: null,         pool: 'categories' },
   };
 
-  // ── État global ────────────────────────────────────────────────────────────
+  const CFG = {
+    maxInsertsPerRun: 8,
+    maxShowInflight: 1,
+    maxShowBatch: 1,
+    showThrottleMs: 1500,
+    showCooldownMs: 15000,
+    showReleaseMs: 350,
+    showFailsafeMs: 8000,
+    batchFlushMs: 80,
+    runDebounceMs: 80,
+    orphanGraceMs: 12000,
+    retireGraceMs: 25000,
+    recentActivityMs: 6000,
+    viewportBufferDesktop: 700,
+    viewportBufferMobile: 350,
+    ioMarginDesktop: '1800px 0px 2200px 0px',
+    ioMarginMobile: '2400px 0px 2800px 0px',
+    maintenanceEveryMs: 1200,
+    minHeightRememberMin: 40,
+  };
 
   const S = {
-    pageKey:      null,
-    cfg:          null,
-    poolsReady:   false,
-    pools:        { topics: [], posts: [], categories: [] },
-    cursors:      { topics: 0,  posts: 0,  categories: 0  },
-    mountedIds:   new Set(),
-    lastShow:     new Map(),
-    io:           null,
-    domObs:       null,
-    mutGuard:     0,     // >0 : mutations DOM en cours (MutationObserver ignoré)
-    inflight:     0,     // showAds() en cours
-    pending:      [],    // ids en attente de slot inflight
-    pendingSet:   new Set(),
-    showBatchTimer: 0,
-    destroyBatchTimer: 0,
-    destroyPending: [],
-    destroyPendingSet: new Set(),
-    sweepQueued:  false,
-    wrapByKey:    new Map(),  // anchorKey → wrap DOM node
-    ezActiveIds:  new Set(),  // ids actifs côté plugin (wrap présent / récemment show)
-    ezShownSinceDestroy: new Set(), // ids déjà show depuis le dernier destroy Ezoic
-    wrapActivityAt: new Map(), // key/id -> ts activité DOM récente
+    cfg: null,
+    poolsReady: false,
+    pools: { topics: [], posts: [], categories: [] },
+    cursors: { topics: 0, posts: 0, categories: 0 },
+    pageKey: null,
+    blockedUntil: 0,
+    runTimer: 0,
+    maintenanceTimer: 0,
+    io: null,
+    domObs: null,
+    muting: 0,
+    mountedIds: new Set(),
+    wrapByKey: new Map(),
+    regById: new Map(),
+    lastShowById: new Map(),
     lastWrapHeightByClass: new Map(),
-    scrollDir:    1,          // 1=bas, -1=haut
-    scrollSpeed:  0,          // px/s approx (EMA)
-    lastScrollY:  0,
-    lastScrollTs: 0,
-    runQueued:    false,
-    burstActive:  false,
-    burstDeadline: 0,
-    burstCount:   0,
-    lastBurstTs:  0,
+    pendingShow: [],
+    pendingSet: new Set(),
+    showTimer: 0,
+    inflightShow: 0,
   };
 
-  let blockedUntil = 0;
-
-  const ts        = () => Date.now();
-  const isBlocked = () => ts() < blockedUntil;
-  const isMobile  = () => { try { return window.innerWidth < 768; } catch (_) { return false; } };
-  const normBool  = v  => v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
-  const isFilled  = n  => !!(n?.querySelector?.(FILL_SEL));
-
-  function viewportBufferPx() {
-    return isMobile() ? VIEWPORT_BUFFER_MOBILE : VIEWPORT_BUFFER_DESKTOP;
-  }
-
-  function textSig(el) {
-    if (!(el instanceof Element)) return '';
-    const parts = [el.id || '', String(el.className || ''), el.getAttribute?.('name') || ''];
-    try {
-      for (const a of ['data-google-query-id', 'data-google-container-id', 'data-slot', 'data-ad-slot']) {
-        const v = el.getAttribute?.(a);
-        if (v) parts.push(v);
-      }
-    } catch (_) {}
-    return parts.join(' ').toLowerCase();
-  }
-
-  function isSpecialSlotLike(el) {
-    const sig = textSig(el);
-    return /adhesion|interstitial|anchor|sticky|outofpage/.test(sig);
-  }
-
-  function hasSpecialSlotMarkers(root) {
-    if (!(root instanceof Element)) return false;
-    if (isSpecialSlotLike(root)) return true;
-    try {
-      const nodes = root.querySelectorAll('[id],[class],[name],[data-slot],[data-ad-slot]');
-      for (const n of nodes) if (isSpecialSlotLike(n)) return true;
-    } catch (_) {}
-    return false;
-  }
-
-  function hasFixedLikeNode(root, maxScan = 24) {
-    if (!(root instanceof Element)) return false;
-    const q = [root];
-    let seen = 0;
-    while (q.length && seen < maxScan) {
-      const n = q.shift();
-      seen++;
-      try {
-        const cs = window.getComputedStyle(n);
-        if (cs.position === 'fixed' || cs.position === 'sticky') return true;
-      } catch (_) {}
-      for (const c of n.children || []) q.push(c);
-    }
-    return false;
-  }
-
-  function markWrapActivity(wrapOrId) {
-    const t = ts();
-    try {
-      if (wrapOrId instanceof Element) {
-        const key = wrapOrId.getAttribute(A_ANCHOR);
-        const id = parseInt(wrapOrId.getAttribute(A_WRAPID), 10);
-        if (key) S.wrapActivityAt.set(`k:${key}`, t);
-        if (Number.isFinite(id)) S.wrapActivityAt.set(`i:${id}`, t);
-        return;
-      }
-      const id = parseInt(wrapOrId, 10);
-      if (Number.isFinite(id)) S.wrapActivityAt.set(`i:${id}`, t);
-    } catch (_) {}
-  }
-
-  function wrapRecentActivity(w) {
-    try {
-      const key = w?.getAttribute?.(A_ANCHOR);
-      const id = parseInt(w?.getAttribute?.(A_WRAPID), 10);
-      const t1 = key ? (S.wrapActivityAt.get(`k:${key}`) || 0) : 0;
-      const t2 = Number.isFinite(id) ? (S.wrapActivityAt.get(`i:${id}`) || 0) : 0;
-      const t3 = parseInt(w?.getAttribute?.(A_SHOWN) || '0', 10) || 0;
-      return (ts() - Math.max(t1, t2, t3)) < RECENT_WRAP_ACTIVITY_MS;
-    } catch (_) { return false; }
-  }
-
-  function wrapCleanupGraceMs(w) {
-    return (hasSpecialSlotMarkers(w) || hasFixedLikeNode(w)) ? SPECIAL_GRACE_MS : CLEANUP_GRACE_MS;
-  }
-
-  function wrapNearViewport(w) {
-    try {
-      const r = w.getBoundingClientRect();
-      const b = viewportBufferPx();
-      const vh = window.innerHeight || 800;
-      return r.bottom > -b && r.top < vh + b;
-    } catch (_) { return true; }
-  }
-
-  function rememberWrapHeight(w) {
-    try {
-      if (!(w instanceof Element)) return;
-      const klass = [...(w.classList || [])].find(c => c.startsWith('ezoic-ad-'));
-      if (!klass) return;
-      const h = Math.round(w.getBoundingClientRect().height || 0);
-      if (h >= 40) S.lastWrapHeightByClass.set(klass, h);
-    } catch (_) {}
-  }
-
-  function healFalseEmpty(root = document) {
-    try {
-      const list = [];
-      if (root instanceof Element && root.classList?.contains(WRAP_CLASS)) list.push(root);
-      const found = root.querySelectorAll ? root.querySelectorAll(`.${WRAP_CLASS}.is-empty`) : [];
-      for (const w of found) list.push(w);
-      for (const w of list) {
-        if (!w?.classList?.contains('is-empty')) continue;
-        if (isFilled(w)) w.classList.remove('is-empty');
-      }
-    } catch (_) {}
-  }
-
-  function phEl(id) {
-    return document.getElementById(`${PH_PREFIX}${id}`);
-  }
-
-  function hasSinglePlaceholder(id) {
-    try { return document.querySelectorAll(`#${PH_PREFIX}${id}`).length === 1; } catch (_) { return false; }
-  }
-
-  function canShowPlaceholderId(id, now = ts()) {
-    const n = parseInt(id, 10);
-    if (!Number.isFinite(n) || n <= 0) return false;
-    if (now - (S.lastShow.get(n) ?? 0) < SHOW_THROTTLE_MS) return false;
-    const ph = phEl(n);
-    if (!ph?.isConnected || isFilled(ph)) return false;
-    if (!hasSinglePlaceholder(n)) return false;
-    return true;
-  }
-
-  function queueSweepDeadWraps() {
-    if (S.sweepQueued) return;
-    S.sweepQueued = true;
-    requestAnimationFrame(() => {
-      S.sweepQueued = false;
-      sweepDeadWraps();
-      healFalseEmpty();
-    });
-  }
-
-  function getDynamicShowBatchMax() {
-    const speed = S.scrollSpeed || 0;
-    const pend  = S.pending.length;
-    // Scroll très rapide => petits batches (réduit le churn/unused)
-    if (speed > 2600) return 2;
-    if (speed > 1400) return 3;
-    // Peu de candidats => flush plus vite, inutile d'attendre 4
-    if (pend <= 1) return 1;
-    if (pend <= 3) return 2;
-    // Par défaut compromis dynamique
-    return 3;
-  }
+  const now = () => Date.now();
+  const isBlocked = () => now() < S.blockedUntil;
+  const isMobile = () => {
+    try { return window.innerWidth < 768; } catch (_) { return false; }
+  };
+  const viewportBuffer = () => (isMobile() ? CFG.viewportBufferMobile : CFG.viewportBufferDesktop);
+  const normBool = v => v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
 
   function mutate(fn) {
-    S.mutGuard++;
-    try { fn(); } finally { S.mutGuard--; }
+    S.muting++;
+    try { return fn(); } finally { S.muting = Math.max(0, S.muting - 1); }
   }
-function scheduleDestroyFlush() {
-  if (S.destroyBatchTimer) return;
-  S.destroyBatchTimer = setTimeout(() => {
-    S.destroyBatchTimer = 0;
-    flushDestroyBatch();
-  }, DESTROY_FLUSH_MS);
-}
 
-function flushDestroyBatch() {
-  if (!S.destroyPending.length) return;
-  const ids = [];
-  while (S.destroyPending.length && ids.length < MAX_DESTROY_BATCH) {
-    const id = S.destroyPending.shift();
-    S.destroyPendingSet.delete(id);
-    if (!Number.isFinite(id) || id <= 0) continue;
-    ids.push(id);
-  }
-  if (ids.length) {
+  function pageKey() {
     try {
-      const ez = window.ezstandalone;
-      const run = () => { try { ez?.destroyPlaceholders?.(ids); } catch (_) {} };
-      try { (typeof ez?.cmd?.push === 'function') ? ez.cmd.push(run) : run(); } catch (_) {}
+      const d = window.ajaxify?.data;
+      if (d?.tid) return `t:${d.tid}`;
+      if (d?.cid) return `c:${d.cid}`;
     } catch (_) {}
+    return location.pathname;
   }
-  if (S.destroyPending.length) scheduleDestroyFlush();
-}
 
-function destroyEzoicId(id) {
-  if (!Number.isFinite(id) || id <= 0) return;
-  if (!S.ezActiveIds.has(id)) return;
-  S.ezActiveIds.delete(id);
-  if (!S.destroyPendingSet.has(id)) {
-    S.destroyPending.push(id);
-    S.destroyPendingSet.add(id);
+  function getKind() {
+    const p = location.pathname;
+    if (/^\/topic\//.test(p)) return 'topic';
+    if (/^\/category\//.test(p)) return 'categoryTopics';
+    if (p === '/' || /^\/categories/.test(p)) return 'categories';
+    if (document.querySelector(SEL.post)) return 'topic';
+    if (document.querySelector(SEL.topic)) return 'categoryTopics';
+    if (document.querySelector(SEL.category)) return 'categories';
+    return 'other';
   }
-  scheduleDestroyFlush();
-}
 
-function destroyBeforeReuse(ids) {
-  const out = [];
-  const toDestroy = [];
-  const seen = new Set();
-  for (const raw of (ids || [])) {
-    const id = parseInt(raw, 10);
-    if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-    seen.add(id);
-    out.push(id);
-    try {
-      const wrap = phEl(id)?.closest?.(WRAP_SEL) || null;
-      if (wrap && (wrapRecentActivity(wrap) || hasSpecialSlotMarkers(wrap) || hasFixedLikeNode(wrap))) {
-        continue;
-      }
-    } catch (_) {}
-    if (S.ezShownSinceDestroy.has(id)) toDestroy.push(id);
-  }
-  if (toDestroy.length) {
-    try {
-      const ez = window.ezstandalone;
-      const run = () => { try { ez?.destroyPlaceholders?.(toDestroy); } catch (_) {} };
-      try { (typeof ez?.cmd?.push === 'function') ? ez.cmd.push(run) : run(); } catch (_) {}
-    } catch (_) {}
-    for (const id of toDestroy) S.ezShownSinceDestroy.delete(id);
+  function getPosts() {
+    return Array.from(document.querySelectorAll(SEL.post)).filter(el => {
+      if (!el.isConnected) return false;
+      if (!el.querySelector('[component="post/content"]')) return false;
+      const p = el.parentElement?.closest?.(SEL.post);
+      if (p && p !== el) return false;
+      return el.getAttribute('component') !== 'post/parent';
+    });
   }
-  return out;
-}
-
-  // ── Config ─────────────────────────────────────────────────────────────────
+  const getTopics = () => Array.from(document.querySelectorAll(SEL.topic));
+  const getCategories = () => Array.from(document.querySelectorAll(SEL.category));
 
   async function fetchConfig() {
     if (S.cfg) return S.cfg;
@@ -334,9 +120,10 @@ function destroyBeforeReuse(ids) {
   }
 
   function parseIds(raw) {
-    const out = [], seen = new Set();
-    for (const v of String(raw || '').split(/\r?\n/).map(s => s.trim()).filter(Boolean)) {
-      const n = parseInt(v, 10);
+    const out = [];
+    const seen = new Set();
+    for (const line of String(raw || '').split(/\r?\n/)) {
+      const n = parseInt(line.trim(), 10);
       if (n > 0 && Number.isFinite(n) && !seen.has(n)) { seen.add(n); out.push(n); }
     }
     return out;
@@ -344,258 +131,147 @@ function destroyBeforeReuse(ids) {
 
   function initPools(cfg) {
     if (S.poolsReady) return;
-    S.pools.topics     = parseIds(cfg.placeholderIds);
-    S.pools.posts      = parseIds(cfg.messagePlaceholderIds);
-    S.pools.categories = parseIds(cfg.categoryPlaceholderIds);
+    S.pools = {
+      topics: parseIds(cfg.placeholderIds),
+      posts: parseIds(cfg.messagePlaceholderIds),
+      categories: parseIds(cfg.categoryPlaceholderIds),
+    };
     S.poolsReady = true;
   }
 
-  // ── Page identity ──────────────────────────────────────────────────────────
+  function textSig(el) {
+    if (!(el instanceof Element)) return '';
+    const parts = [el.id || '', String(el.className || ''), el.getAttribute('name') || ''];
+    for (const a of ['data-slot', 'data-ad-slot', 'data-google-container-id']) {
+      try { const v = el.getAttribute(a); if (v) parts.push(v); } catch (_) {}
+    }
+    return parts.join(' ').toLowerCase();
+  }
 
-  function pageKey() {
+  function isSpecialLike(root) {
+    if (!(root instanceof Element)) return false;
+    const test = el => /adhesion|interstitial|anchor|sticky|outofpage/.test(textSig(el));
+    if (test(root)) return true;
     try {
-      const d = window.ajaxify?.data;
-      if (d?.tid) return `t:${d.tid}`;
-      if (d?.cid) return `c:${d.cid}`;
+      const nodes = root.querySelectorAll('[id],[class],[name],[data-slot],[data-ad-slot]');
+      for (const n of nodes) if (test(n)) return true;
     } catch (_) {}
-    return location.pathname;
-  }
-
-  function getKind() {
-    const p = location.pathname;
-    if (/^\/topic\//.test(p))                 return 'topic';
-    if (/^\/category\//.test(p))              return 'categoryTopics';
-    if (p === '/' || /^\/categories/.test(p)) return 'categories';
-    if (document.querySelector(SEL.category)) return 'categories';
-    if (document.querySelector(SEL.post))     return 'topic';
-    if (document.querySelector(SEL.topic))    return 'categoryTopics';
-    return 'other';
-  }
-
-  // ── Items DOM ──────────────────────────────────────────────────────────────
-
-  function getPosts() {
-    return Array.from(document.querySelectorAll(SEL.post)).filter(el => {
-      if (!el.isConnected) return false;
-      if (!el.querySelector('[component="post/content"]')) return false;
-      const p = el.parentElement?.closest(SEL.post);
-      if (p && p !== el) return false;
-      return el.getAttribute('component') !== 'post/parent';
-    });
+    return false;
   }
 
-  const getTopics     = () => Array.from(document.querySelectorAll(SEL.topic));
-  const getCategories = () => Array.from(document.querySelectorAll(SEL.category));
-
-  // ── Wraps — détection ──────────────────────────────────────────────────────
-
-  /**
-   * Vérifie qu'un wrap a encore son ancre dans le DOM.
-   * Utilisé par adjacentWrap pour ignorer les wraps orphelins.
-   */
-  function wrapIsLive(wrap) {
-    if (!wrap?.classList?.contains(WRAP_CLASS)) return false;
-    const key = wrap.getAttribute(A_ANCHOR);
-    if (!key) return false;
-    // Lookup O(1) dans le registre — vrai si le wrap EST encore dans le registre
-    // et connecté au DOM (le registre est tenu à jour par insertAfter/dropWrap).
-    if (S.wrapByKey.get(key) === wrap) return wrap.isConnected;
-    // Fallback : registre pas encore à jour ou wrap non enregistré.
-    const colonIdx = key.indexOf(':');
-    const klass    = key.slice(0, colonIdx);
-    const anchorId = key.slice(colonIdx + 1);
-    const cfg = KIND[klass];
-    if (!cfg) return false;
-    // Optimisation : si l'ancre est un frère direct du wrap, pas besoin
-    // de querySelector global — on cherche parmi les voisins immédiats.
-    const parent = wrap.parentElement;
-    if (parent) {
-      for (const sib of parent.children) {
-        if (sib === wrap) continue;
-        try {
-          if (sib.matches(`${cfg.baseTag || ''}[${cfg.anchorAttr}="${anchorId}"]`)) {
-            return sib.isConnected;
-          }
-        } catch (_) {}
-      }
+  function hasFixedLike(root, max = 16) {
+    if (!(root instanceof Element)) return false;
+    const q = [root];
+    let seen = 0;
+    while (q.length && seen < max) {
+      const n = q.shift();
+      seen++;
+      try {
+        const cs = window.getComputedStyle(n);
+        if (cs.position === 'fixed' || cs.position === 'sticky') return true;
+      } catch (_) {}
+      for (const c of n.children || []) q.push(c);
     }
-    // Dernier recours : querySelector global
-    try {
-      const found = document.querySelector(`${cfg.sel}[${cfg.anchorAttr}="${anchorId}"]`);
-      return !!(found?.isConnected);
-    } catch (_) { return false; }
+    return false;
   }
 
-  function adjacentWrap(el) {
-    return wrapIsLive(el.nextElementSibling) || wrapIsLive(el.previousElementSibling);
+  function isFilled(wrap) {
+    try { return !!wrap?.querySelector?.('iframe, ins, img, video, [data-google-container-id]'); } catch (_) { return false; }
   }
 
-  // ── Ancres stables ─────────────────────────────────────────────────────────
+  function phEl(id) { return document.getElementById(`${PH_PREFIX}${id}`); }
 
-  /**
-   * Retourne la valeur de l'attribut stable pour cet élément,
-   * ou un fallback positionnel si l'attribut est absent.
-   */
-  function stableId(klass, el) {
+  function anchorStableId(klass, el) {
     const attr = KIND[klass]?.anchorAttr;
     if (attr) {
       const v = el.getAttribute(attr);
       if (v !== null && v !== '') return v;
     }
     let i = 0;
-    for (const s of el.parentElement?.children ?? []) {
-      if (s === el) return `i${i}`;
-      i++;
-    }
+    for (const s of el.parentElement?.children || []) { if (s === el) return `i${i}`; i++; }
     return 'i0';
   }
+  const anchorKey = (klass, el) => `${klass}:${anchorStableId(klass, el)}`;
 
-  const anchorKey = (klass, el) => `${klass}:${stableId(klass, el)}`;
-
-  function findWrap(key) {
+  function findWrapByKey(key) {
     const w = S.wrapByKey.get(key);
     return (w?.isConnected) ? w : null;
   }
 
-  // ── Pool ───────────────────────────────────────────────────────────────────
+  function rememberWrapHeight(wrap) {
+    try {
+      if (!(wrap instanceof Element)) return;
+      const klass = [...(wrap.classList || [])].find(c => c.startsWith('ezoic-ad-'));
+      if (!klass) return;
+      const h = Math.round(wrap.getBoundingClientRect().height || 0);
+      if (h >= CFG.minHeightRememberMin) S.lastWrapHeightByClass.set(klass, h);
+    } catch (_) {}
+  }
 
-  /**
-   * Retourne le prochain id disponible dans le pool (round-robin),
-   * ou null si tous les ids sont montés.
-   */
-  function pickId(poolKey) {
-    const pool = S.pools[poolKey];
-    if (!pool.length) return null;
-    for (let t = 0; t < pool.length; t++) {
-      const i = S.cursors[poolKey] % pool.length;
-      S.cursors[poolKey] = (S.cursors[poolKey] + 1) % pool.length;
-      const id = pool[i];
-      if (!S.mountedIds.has(id)) return id;
-    }
-    return null;
+  function wrapNearViewport(wrap) {
+    try {
+      const r = wrap.getBoundingClientRect();
+      const b = viewportBuffer();
+      const vh = window.innerHeight || 800;
+      return r.bottom > -b && r.top < vh + b;
+    } catch (_) { return true; }
   }
 
-  function sweepDeadWraps() {
-    // NodeBB peut retirer des nœuds sans passer par dropWrap() (virtualisation / rerender).
-    // On libère alors les IDs/keys fantômes pour éviter l'épuisement du pool.
-    let changed = false;
-    for (const [key, wrap] of S.wrapByKey) {
-      if (wrap?.isConnected) continue;
-      changed = true;
-      S.wrapByKey.delete(key);
-      const id = parseInt(wrap?.getAttribute?.(A_WRAPID), 10);
-      if (Number.isFinite(id)) {
-        S.mountedIds.delete(id);
-        S.pendingSet.delete(id);
-        S.lastShow.delete(id);
-        S.ezActiveIds.delete(id);
-      }
+  function ensureRegistry(id, wrap) {
+    let rec = S.regById.get(id);
+    if (!rec) {
+      rec = {
+        id,
+        wrap,
+        key: wrap?.getAttribute(A_ANCHOR) || '',
+        state: 'idle',
+        typeClass: [...(wrap?.classList || [])].find(c => c.startsWith('ezoic-ad-')) || '',
+        isSpecial: false,
+        isFixedLike: false,
+        createdAt: now(),
+        shownAt: 0,
+        lastSeenAt: 0,
+        lastMutationAt: now(),
+        cooldownUntil: 0,
+      };
+      S.regById.set(id, rec);
     }
-    if (changed && S.pending.length) {
-      S.pending = S.pending.filter(id => S.pendingSet.has(id));
+    if (wrap && rec.wrap !== wrap) rec.wrap = wrap;
+    if (wrap) {
+      rec.key = wrap.getAttribute(A_ANCHOR) || rec.key;
+      rec.typeClass = [...(wrap.classList || [])].find(c => c.startsWith('ezoic-ad-')) || rec.typeClass;
     }
+    return rec;
   }
 
-  /**
-   * Pool épuisé : recycle un wrap loin au-dessus du viewport.
-   * Séquence avec délais (destroyPlaceholders est asynchrone) :
-   *   destroy([id]) → 300ms → define([id]) → 300ms → displayMore([id])
-   * displayMore = API Ezoic prévue pour l'infinite scroll.
-   * Priorité : wraps vides d'abord, remplis si nécessaire.
-   */
-function recycleAndMove(klass, targetEl, newKey) {
-  const ez = window.ezstandalone;
-  if (typeof ez?.destroyPlaceholders !== 'function' ||
-      typeof ez?.define             !== 'function' ||
-      typeof ez?.displayMore        !== 'function') return null;
-
-  const vh = window.innerHeight || 800;
-  const preferAbove = S.scrollDir >= 0; // scroll bas => recycle en haut
-  const farAbove = -vh;
-  const farBelow = vh * 2;
-
-  let bestPrefEmpty = null, bestPrefMetric = Infinity;
-  let bestPrefFilled = null, bestPrefFilledMetric = Infinity;
-  let bestAnyEmpty = null, bestAnyMetric = Infinity;
-  let bestAnyFilled = null, bestAnyFilledMetric = Infinity;
-
-  for (const wrap of S.wrapByKey.values()) {
-    if (!wrap?.isConnected || !wrap.classList?.contains(WRAP_CLASS) || !wrap.classList.contains(klass)) continue;
-    if (wrapRecentActivity(wrap)) continue;
-    if (hasSpecialSlotMarkers(wrap) || hasFixedLikeNode(wrap)) continue;
-    try {
-      const rect = wrap.getBoundingClientRect();
-      const isAbove = rect.bottom <= farAbove;
-      const isBelow = rect.top >= farBelow;
-      const anyFar = isAbove || isBelow;
-      if (!anyFar) continue;
-
-      const qualifies = preferAbove ? isAbove : isBelow;
-      const metric = preferAbove ? Math.abs(rect.bottom) : Math.abs(rect.top - vh);
-      const filled = isFilled(wrap);
-
-      if (qualifies) {
-        if (!filled) {
-          if (metric < bestPrefMetric) { bestPrefMetric = metric; bestPrefEmpty = wrap; }
-        } else {
-          if (metric < bestPrefFilledMetric) { bestPrefFilledMetric = metric; bestPrefFilled = wrap; }
-        }
-      }
-      if (!filled) {
-        if (metric < bestAnyMetric) { bestAnyMetric = metric; bestAnyEmpty = wrap; }
-      } else {
-        if (metric < bestAnyFilledMetric) { bestAnyFilledMetric = metric; bestAnyFilled = wrap; }
-      }
-    } catch (_) {}
+  function updateWrapState(rec, state) {
+    rec.state = state;
+    try { rec.wrap?.setAttribute?.(A_STATE, state); } catch (_) {}
   }
 
-  const best = bestPrefEmpty ?? bestPrefFilled ?? bestAnyEmpty ?? bestAnyFilled;
-  if (!best) return null;
-  const id = parseInt(best.getAttribute(A_WRAPID), 10);
-  if (!Number.isFinite(id)) return null;
-
-  const oldKey = best.getAttribute(A_ANCHOR);
-  try { const ph = best.querySelector(`#${PH_PREFIX}${id}`); if (ph) S.io?.unobserve(ph); } catch (_) {}
-  mutate(() => {
-    rememberWrapHeight(best);
-    best.setAttribute(A_ANCHOR,  newKey);
-    best.setAttribute(A_CREATED, String(ts()));
-    best.setAttribute(A_SHOWN,   '0');
-    best.classList.remove('is-empty');
-    const ph = best.querySelector(`#${PH_PREFIX}${id}`);
-    if (ph) ph.innerHTML = '';
-    targetEl.insertAdjacentElement('afterend', best);
-  });
-  if (oldKey && S.wrapByKey.get(oldKey) === best) S.wrapByKey.delete(oldKey);
-  S.wrapByKey.set(newKey, best);
-
-  const doDestroy = () => {
-    if (S.ezShownSinceDestroy.has(id)) {
-      try { ez.destroyPlaceholders([id]); } catch (_) {}
-      S.ezShownSinceDestroy.delete(id);
+  function pickId(poolKey) {
+    const pool = S.pools[poolKey] || [];
+    if (!pool.length) return null;
+    for (let t = 0; t < pool.length; t++) {
+      const idx = S.cursors[poolKey] % pool.length;
+      S.cursors[poolKey] = (S.cursors[poolKey] + 1) % pool.length;
+      const id = pool[idx];
+      if (!S.mountedIds.has(id)) return id;
     }
-    S.ezActiveIds.delete(id);
-    setTimeout(doDefine, 330);
-  };
-  const doDefine  = () => { try { ez.define([id]); } catch (_) {} setTimeout(doDisplay, 300); };
-  const doDisplay = () => { try { ez.displayMore([id]); S.ezActiveIds.add(id); S.ezShownSinceDestroy.add(id); } catch (_) {} };
-  try { (typeof ez.cmd?.push === 'function') ? ez.cmd.push(doDestroy) : doDestroy(); } catch (_) {}
-
-  return { id, wrap: best };
-}
-
-  // ── Wraps DOM — création / suppression ────────────────────────────────────
+    return null;
+  }
 
   function makeWrap(id, klass, key) {
     const w = document.createElement('div');
     w.className = `${WRAP_CLASS} ${klass}`;
-    w.setAttribute(A_ANCHOR,  key);
-    w.setAttribute(A_WRAPID,  String(id));
-    w.setAttribute(A_CREATED, String(ts()));
-    w.setAttribute(A_SHOWN,   '0');
-    w.style.cssText = 'width:100%;display:block;';
-    const cachedH = S.lastWrapHeightByClass.get(klass);
-    if (Number.isFinite(cachedH) && cachedH > 0) w.style.minHeight = `${cachedH}px`;
+    w.setAttribute(A_ANCHOR, key);
+    w.setAttribute(A_WRAPID, String(id));
+    w.setAttribute(A_CREATED, String(now()));
+    w.setAttribute(A_SHOWN, '0');
+    w.setAttribute(A_STATE, 'idle');
+    w.style.cssText = 'display:block;width:100%;';
+    const h = S.lastWrapHeightByClass.get(klass);
+    if (Number.isFinite(h) && h > 0) w.style.minHeight = `${h}px`;
     const ph = document.createElement('div');
     ph.id = `${PH_PREFIX}${id}`;
     ph.setAttribute('data-ezoic-id', String(id));
@@ -603,473 +279,431 @@ function recycleAndMove(klass, targetEl, newKey) {
     return w;
   }
 
-  function insertAfter(el, id, klass, key) {
-    if (!el?.insertAdjacentElement)                                 return null;
-    if (findWrap(key))                                              return null;
-    if (S.mountedIds.has(id))                                       return null;
-    if (document.getElementById(`${PH_PREFIX}${id}`)?.isConnected) return null;
+  function insertWrapAfter(anchorEl, id, klass, key) {
+    if (!anchorEl?.insertAdjacentElement) return null;
+    if (findWrapByKey(key)) return null;
+    if (S.mountedIds.has(id)) return null;
+    if (phEl(id)?.isConnected) return null;
     const w = makeWrap(id, klass, key);
-    mutate(() => el.insertAdjacentElement('afterend', w));
+    mutate(() => anchorEl.insertAdjacentElement('afterend', w));
     S.mountedIds.add(id);
     S.wrapByKey.set(key, w);
+    const rec = ensureRegistry(id, w);
+    rec.key = key;
+    rec.createdAt = now();
+    rec.lastMutationAt = now();
+    rec.isSpecial = false;
+    rec.isFixedLike = false;
+    updateWrapState(rec, 'idle');
+    observePlaceholder(id);
     return w;
   }
 
-  function dropWrap(w) {
+  function releaseWrap(wrap) {
     try {
-      rememberWrapHeight(w);
-      const ph = w.querySelector(`[id^="${PH_PREFIX}"]`);
-      if (ph instanceof Element) S.io?.unobserve(ph);
-      const id = parseInt(w.getAttribute(A_WRAPID), 10);
-      if (Number.isFinite(id)) { S.ezActiveIds.delete(id); S.mountedIds.delete(id); }
-      const key = w.getAttribute(A_ANCHOR);
-      if (key) S.wrapActivityAt.delete(`k:${key}`);
-      if (Number.isFinite(id)) S.wrapActivityAt.delete(`i:${id}`);
-      if (key && S.wrapByKey.get(key) === w) S.wrapByKey.delete(key);
-      w.remove();
+      rememberWrapHeight(wrap);
+      const id = parseInt(wrap.getAttribute(A_WRAPID), 10);
+      const key = wrap.getAttribute(A_ANCHOR) || '';
+      const ph = wrap.querySelector(`[id^="${PH_PREFIX}"]`);
+      if (ph) try { S.io?.unobserve(ph); } catch (_) {}
+      if (key && S.wrapByKey.get(key) === wrap) S.wrapByKey.delete(key);
+      if (Number.isFinite(id)) {
+        S.mountedIds.delete(id);
+        S.pendingSet.delete(id);
+        S.lastShowById.delete(id);
+        const rec = S.regById.get(id);
+        if (rec) {
+          rec.wrap = null;
+          rec.state = 'retired';
+          rec.cooldownUntil = Math.max(rec.cooldownUntil || 0, now() + 3000);
+        }
+      }
+      wrap.remove();
     } catch (_) {}
   }
 
-  // ── Prune (topics de catégorie uniquement) ────────────────────────────────
-  //
-  // Réactivé uniquement pour 'ezoic-ad-between' (liste de topics).
-  //
-  // Safe ici car NodeBB ne virtualise PAS les topics dans une catégorie :
-  //   les li[component="category/topic"] restent dans le DOM pendant toute
-  //   la session. Un wrap orphelin (ancre absente) signifie vraiment que le
-  //   topic a disparu. Sans ce nettoyage, les wraps s'accumulent en tête de
-  //   liste après un long scroll et bloquent les nouvelles injections.
-  //
-  // Toujours désactivé pour 'ezoic-ad-message' (posts de topic) :
-  //   NodeBB virtualise les posts hors-viewport — il les retire puis les
-  //   réinsère. pruneOrphans verrait des ancres temporairement absentes,
-  //   supprimerait les wraps, et provoquerait une réinjection en haut.
-
-  function pruneOrphansBetween() {
-    const klass = 'ezoic-ad-between';
-    const cfg   = KIND[klass];
+  function wrapHasAnchor(wrap) {
+    const key = wrap?.getAttribute?.(A_ANCHOR);
+    if (!key) return false;
+    const i = key.indexOf(':');
+    const klass = key.slice(0, i);
+    const sid = key.slice(i + 1);
+    const def = KIND[klass];
+    if (!def) return false;
+    try {
+      const sel = `${def.sel}[${def.anchorAttr}="${sid}"]`;
+      return !!document.querySelector(sel);
+    } catch (_) { return false; }
+  }
 
-    document.querySelectorAll(`${WRAP_SEL}.${klass}`).forEach(w => {
-      const created = parseInt(w.getAttribute(A_CREATED) || '0', 10);
-      if (ts() - created < Math.max(MIN_PRUNE_AGE_MS, wrapCleanupGraceMs(w))) return;
-      if (wrapRecentActivity(w) || wrapNearViewport(w)) return;
+  function sweepDisconnected() {
+    for (const [key, wrap] of [...S.wrapByKey.entries()]) {
+      if (wrap?.isConnected) continue;
+      S.wrapByKey.delete(key);
+      const id = parseInt(wrap?.getAttribute?.(A_WRAPID), 10);
+      if (Number.isFinite(id)) {
+        S.mountedIds.delete(id);
+        S.pendingSet.delete(id);
+      }
+    }
+  }
 
-      const key = w.getAttribute(A_ANCHOR) ?? '';
-      const sid = key.slice(klass.length + 1); // après "ezoic-ad-between:"
-      if (!sid) { mutate(() => dropWrap(w)); return; }
+  function classifyWrap(rec) {
+    const w = rec.wrap;
+    if (!w?.isConnected) return;
+    if (!rec.isSpecial) rec.isSpecial = isSpecialLike(w);
+    if (!rec.isFixedLike) rec.isFixedLike = hasFixedLike(w);
+  }
 
-      const anchorEl = document.querySelector(`${cfg.baseTag}[${cfg.anchorAttr}="${sid}"]`);
-      if (!anchorEl?.isConnected) mutate(() => dropWrap(w));
-    });
+  function maintenance() {
+    if (isBlocked()) return;
+    sweepDisconnected();
+    const t = now();
+    for (const [id, rec] of S.regById) {
+      const w = rec.wrap;
+      if (!w?.isConnected) continue;
+      classifyWrap(rec);
+      if (wrapNearViewport(w)) {
+        rec.lastSeenAt = t;
+        if (rec.state === 'retiring') updateWrapState(rec, 'live');
+        continue;
+      }
+      const created = parseInt(w.getAttribute(A_CREATED) || '0', 10) || rec.createdAt || 0;
+      const shown = parseInt(w.getAttribute(A_SHOWN) || '0', 10) || rec.shownAt || 0;
+      const age = t - Math.max(created, shown || 0, rec.lastMutationAt || 0);
+      const activeRecently = (t - (rec.lastMutationAt || 0)) < CFG.recentActivityMs;
+      const filled = isFilled(w);
+      if (filled) { rec.lastMutationAt = t; rec.shownAt = Math.max(rec.shownAt || 0, shown || 0); }
+      if (rec.isSpecial || rec.isFixedLike) continue; // never retire plugin-side
+      if (activeRecently) continue;
+      if (filled) continue; // keep rendered slots stable; no aggressive destroy/recycle
+      if (age < CFG.retireGraceMs) continue;
+      if (rec.state !== 'retiring') {
+        updateWrapState(rec, 'retiring');
+        continue;
+      }
+      // second pass confirmation
+      if (wrapNearViewport(w) || isFilled(w)) { updateWrapState(rec, 'live'); continue; }
+      releaseWrap(w);
+    }
   }
 
-  // ── Injection ──────────────────────────────────────────────────────────────
+  function scheduleMaintenance() {
+    if (S.maintenanceTimer) return;
+    S.maintenanceTimer = setTimeout(() => {
+      S.maintenanceTimer = 0;
+      maintenance();
+    }, CFG.maintenanceEveryMs);
+  }
 
-  /**
-   * Ordinal 0-based pour le calcul de l'intervalle d'injection.
-   * Utilise ordinalAttr si défini, sinon compte les frères dans le parent.
-   */
   function ordinal(klass, el) {
     const attr = KIND[klass]?.ordinalAttr;
     if (attr) {
       const v = el.getAttribute(attr);
       if (v !== null && v !== '' && !isNaN(v)) return parseInt(v, 10);
     }
-    const fullSel = KIND[klass]?.sel ?? '';
     let i = 0;
-    for (const s of el.parentElement?.children ?? []) {
+    const fullSel = KIND[klass]?.sel || '';
+    for (const s of el.parentElement?.children || []) {
       if (s === el) return i;
       if (!fullSel || s.matches?.(fullSel)) i++;
     }
     return 0;
   }
 
-  function injectBetween(klass, items, interval, showFirst, poolKey) {
-    if (!items.length) return 0;
-    let inserted = 0;
+  function adjacentManagedWrap(el) {
+    const isManaged = n => !!(n?.classList?.contains(WRAP_CLASS) && n.isConnected);
+    return isManaged(el.nextElementSibling) || isManaged(el.previousElementSibling);
+  }
 
+  function injectFor(klass, items, interval, showFirst) {
+    let inserted = 0;
+    const poolKey = KIND[klass].pool;
     for (const el of items) {
-      if (inserted >= MAX_INSERTS_RUN) break;
+      if (inserted >= CFG.maxInsertsPerRun) break;
       if (!el?.isConnected) continue;
-
       const ord = ordinal(klass, el);
       if (!(showFirst && ord === 0) && (ord + 1) % interval !== 0) continue;
-      if (adjacentWrap(el)) continue;
-
+      if (adjacentManagedWrap(el)) continue;
       const key = anchorKey(klass, el);
-      if (findWrap(key)) continue;
-
-      let id = pickId(poolKey);
-      if (!id) { sweepDeadWraps(); id = pickId(poolKey); }
-      if (id) {
-        const w = insertAfter(el, id, klass, key);
-        if (w) { observePh(id); inserted++; }
-      } else {
-        const recycled = recycleAndMove(klass, el, key);
-        if (!recycled) break;
-        inserted++;
-      }
+      if (findWrapByKey(key)) continue;
+      const id = pickId(poolKey);
+      if (!id) break; // no recycle = anti-churn by design
+      if (insertWrapAfter(el, id, klass, key)) inserted++;
     }
     return inserted;
   }
 
-  // ── IntersectionObserver & Show ────────────────────────────────────────────
+  function canShowId(id) {
+    const t = now();
+    const last = S.lastShowById.get(id) || 0;
+    if (t - last < CFG.showThrottleMs) return false;
+    const rec = S.regById.get(id);
+    if (rec && rec.cooldownUntil && t < rec.cooldownUntil) return false;
+    const ph = phEl(id);
+    if (!ph?.isConnected) return false;
+    const wrap = ph.closest?.(`.${WRAP_CLASS}`);
+    if (!wrap?.isConnected) return false;
+    if (!wrapNearViewport(wrap)) {
+      // allow preloading within IO margin only if reasonably close
+      try {
+        const r = ph.getBoundingClientRect();
+        const vh = window.innerHeight || 800;
+        const preload = isMobile() ? 1800 : 1400;
+        if (r.top > vh + preload || r.bottom < -preload) return false;
+      } catch (_) {}
+    }
+    return true;
+  }
 
-  function getIO() {
-    if (S.io) return S.io;
-    try {
-      S.io = new IntersectionObserver(entries => {
-        for (const e of entries) {
-          if (!e.isIntersecting) continue;
-          if (e.target instanceof Element) S.io?.unobserve(e.target);
-          const id = parseInt(e.target.getAttribute('data-ezoic-id'), 10);
-          if (Number.isFinite(id) && id > 0) enqueueShow(id);
-        }
-      }, { root: null, rootMargin: isMobile() ? IO_MARGIN_MOBILE : IO_MARGIN_DESKTOP, threshold: 0 });
-    } catch (_) { S.io = null; }
-    return S.io;
+  function enqueueShow(id) {
+    if (isBlocked()) return;
+    const n = parseInt(id, 10);
+    if (!Number.isFinite(n) || n <= 0) return;
+    if (!S.pendingSet.has(n)) { S.pendingSet.add(n); S.pendingShow.push(n); }
+    if (!S.showTimer) {
+      S.showTimer = setTimeout(() => {
+        S.showTimer = 0;
+        drainShowQueue();
+      }, CFG.batchFlushMs);
+    }
   }
 
-  function observePh(id) {
+  function observePlaceholder(id) {
     const ph = phEl(id);
-    if (ph?.isConnected) try { getIO()?.observe(ph); } catch (_) {}
-    // Fast-path : si déjà proche viewport, ne pas attendre un callback IO complet
+    if (!ph?.isConnected) return;
+    try { getIO()?.observe(ph); } catch (_) {}
     try {
-      if (!ph?.isConnected) return;
-      const rect = ph.getBoundingClientRect();
+      const r = ph.getBoundingClientRect();
       const vh = window.innerHeight || 800;
-      const preload = isMobile() ? 1400 : 1000;
-      if (rect.top <= vh + preload && rect.bottom >= -preload) enqueueShow(id);
+      const preload = isMobile() ? 1600 : 1200;
+      if (r.top <= vh + preload && r.bottom >= -preload) enqueueShow(id);
     } catch (_) {}
   }
 
-function enqueueShow(id) {
-  if (!id || isBlocked()) return;
-  const n = parseInt(id, 10);
-  if (!Number.isFinite(n) || n <= 0) return;
-  if (ts() - (S.lastShow.get(n) ?? 0) < SHOW_THROTTLE_MS) return;
-  if (!S.pendingSet.has(n)) { S.pending.push(n); S.pendingSet.add(n); }
-  scheduleDrainQueue();
-}
-
-function scheduleDrainQueue() {
-  if (isBlocked()) return;
-  if (S.showBatchTimer) return;
-  S.showBatchTimer = setTimeout(() => {
-    S.showBatchTimer = 0;
-    drainQueue();
-  }, BATCH_FLUSH_MS);
-}
-
-function drainQueue() {
-  if (isBlocked()) return;
-  const free = Math.max(0, MAX_INFLIGHT - S.inflight);
-  if (!free || !S.pending.length) return;
+  function startShow(ids) {
+    if (!ids.length || isBlocked()) return;
+    S.inflightShow += ids.length;
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      S.inflightShow = Math.max(0, S.inflightShow - ids.length);
+      drainShowQueue();
+    };
+    const guard = setTimeout(release, CFG.showFailsafeMs);
 
-  const picked = [];
-  const seen = new Set();
-  const batchCap = Math.max(1, Math.min(MAX_SHOW_BATCH, free, getDynamicShowBatchMax()));
-  while (S.pending.length && picked.length < batchCap) {
-    const id = S.pending.shift();
-    S.pendingSet.delete(id);
-    if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-    if (!phEl(id)?.isConnected) continue;
-    seen.add(id);
-    picked.push(id);
+    requestAnimationFrame(() => {
+      try {
+        if (isBlocked()) { clearTimeout(guard); return release(); }
+        window.ezstandalone = window.ezstandalone || {};
+        const ez = window.ezstandalone;
+        const valid = [];
+        const t = now();
+        for (const id of ids) {
+          if (!canShowId(id)) continue;
+          const ph = phEl(id);
+          const wrap = ph?.closest?.(`.${WRAP_CLASS}`);
+          if (!wrap) continue;
+          wrap.setAttribute(A_SHOWN, String(t));
+          const rec = ensureRegistry(id, wrap);
+          rec.wrap = wrap;
+          rec.shownAt = t;
+          rec.lastMutationAt = t;
+          rec.cooldownUntil = t + CFG.showCooldownMs;
+          classifyWrap(rec);
+          updateWrapState(rec, 'showing');
+          S.lastShowById.set(id, t);
+          valid.push(id);
+        }
+        if (!valid.length) { clearTimeout(guard); return release(); }
+        const run = () => {
+          try { ez.showAds(...valid); } catch (_) {
+            try { ez.showAds(valid); } catch (_) {}
+          }
+          setTimeout(() => {
+            for (const id of valid) {
+              const rec = S.regById.get(id);
+              if (!rec) continue;
+              const w = rec.wrap;
+              if (w?.isConnected) {
+                if (isFilled(w)) rec.lastMutationAt = now();
+                updateWrapState(rec, 'live');
+              }
+            }
+            clearTimeout(guard);
+            release();
+          }, CFG.showReleaseMs);
+        };
+        Array.isArray(ez.cmd) ? ez.cmd.push(run) : run();
+      } catch (_) {
+        clearTimeout(guard);
+        release();
+      }
+    });
   }
-  if (picked.length) startShowBatch(picked);
-  if (S.pending.length && (MAX_INFLIGHT - S.inflight) > 0) scheduleDrainQueue();
-}
-
-function startShowBatch(ids) {
-  if (!ids?.length || isBlocked()) return;
-  const reserve = ids.length;
-  S.inflight += reserve;
 
-  let done = false;
-  const release = () => {
-    if (done) return;
-    done = true;
-    S.inflight = Math.max(0, S.inflight - reserve);
-    drainQueue();
-  };
-  const timer = setTimeout(release, SHOW_FAILSAFE_MS);
+  function drainShowQueue() {
+    if (isBlocked()) return;
+    if (S.inflightShow >= CFG.maxShowInflight) return;
+    if (!S.pendingShow.length) return;
+    const cap = Math.min(CFG.maxShowBatch, CFG.maxShowInflight - S.inflightShow);
+    const picked = [];
+    while (S.pendingShow.length && picked.length < cap) {
+      const id = S.pendingShow.shift();
+      S.pendingSet.delete(id);
+      if (!Number.isFinite(id) || id <= 0) continue;
+      if (!phEl(id)?.isConnected) continue;
+      picked.push(id);
+    }
+    if (picked.length) startShow(picked);
+    if (S.pendingShow.length) scheduleMaintenance();
+  }
 
-  requestAnimationFrame(() => {
+  function getIO() {
+    if (S.io) return S.io;
     try {
-      if (isBlocked()) { clearTimeout(timer); return release(); }
-
-      const valid = [];
-      const t = ts();
-
-      for (const raw of ids) {
-        const id = parseInt(raw, 10);
-        if (!Number.isFinite(id) || id <= 0) continue;
-        const ph = phEl(id);
-        if (!canShowPlaceholderId(id, t)) continue;
-
-        S.lastShow.set(id, t);
-        try { const wrap = ph.closest?.(WRAP_SEL); wrap?.setAttribute(A_SHOWN, String(t)); if (wrap) markWrapActivity(wrap); } catch (_) {}
-        valid.push(id);
-      }
-
-      if (!valid.length) { clearTimeout(timer); return release(); }
-
-      window.ezstandalone = window.ezstandalone || {};
-      const ez = window.ezstandalone;
-      const doShow = () => {
-        const prepared = destroyBeforeReuse(valid);
-        if (!prepared.length) { setTimeout(() => { clearTimeout(timer); release(); }, SHOW_RELEASE_MS); return; }
-        try { ez.showAds(...prepared); } catch (_) {}
-        for (const id of prepared) {
-          S.ezActiveIds.add(id);
-          S.ezShownSinceDestroy.add(id);
+      S.io = new IntersectionObserver(entries => {
+        for (const e of entries) {
+          const t = e.target;
+          if (!(t instanceof Element)) continue;
+          const id = parseInt(t.getAttribute('data-ezoic-id'), 10);
+          if (!Number.isFinite(id) || id <= 0) continue;
+          const rec = S.regById.get(id);
+          if (rec) rec.lastSeenAt = now();
+          if (e.isIntersecting) enqueueShow(id);
         }
-        setTimeout(() => { clearTimeout(timer); release(); }, SHOW_RELEASE_MS);
-      };
-      Array.isArray(ez.cmd) ? ez.cmd.push(doShow) : doShow();
-    } catch (_) { clearTimeout(timer); release(); }
-  });
-}
-
-  // ── Patch Ezoic showAds ────────────────────────────────────────────────────
-  //
-  // Intercepte ez.showAds() pour :
-  //   – ignorer les appels pendant blockedUntil
-  //   – filtrer les ids dont le placeholder n'est pas en DOM
+      }, {
+        root: null,
+        rootMargin: isMobile() ? CFG.ioMarginMobile : CFG.ioMarginDesktop,
+        threshold: 0,
+      });
+    } catch (_) { S.io = null; }
+    return S.io;
+  }
 
   function patchShowAds() {
-    const apply = () => {
+    const install = () => {
       try {
         window.ezstandalone = window.ezstandalone || {};
         const ez = window.ezstandalone;
-        if (window.__nbbEzPatched || typeof ez.showAds !== 'function') return;
-        window.__nbbEzPatched = true;
+        if (window.__nbbEzPatchedV22 || typeof ez.showAds !== 'function') return;
+        window.__nbbEzPatchedV22 = true;
         const orig = ez.showAds.bind(ez);
         ez.showAds = function (...args) {
           if (isBlocked()) return;
-          const ids = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+          const ids = (args.length === 1 && Array.isArray(args[0])) ? args[0] : args;
           const valid = [];
           const seen = new Set();
           for (const v of ids) {
             const id = parseInt(v, 10);
             if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-            if (!phEl(id)?.isConnected || !hasSinglePlaceholder(id)) continue;
+            const ph = phEl(id);
+            if (!ph?.isConnected) continue;
+            const wrap = ph.closest?.(`.${WRAP_CLASS}`);
+            if (!wrap?.isConnected) continue;
+            const rec = ensureRegistry(id, wrap);
+            if (rec.cooldownUntil && now() < rec.cooldownUntil && (now() - (rec.shownAt || 0)) < 500) continue;
             seen.add(id);
             valid.push(id);
           }
           if (!valid.length) return;
-          try { orig(...valid); } catch (_) {
-            for (const id of valid) {
-              try { orig(id); } catch (_) {}
-            }
-          }
+          try { return orig(...valid); } catch (_) { try { return orig(valid); } catch (_) {} }
         };
       } catch (_) {}
     };
-    apply();
-    if (!window.__nbbEzPatched) {
+    install();
+    if (!window.__nbbEzPatchedV22) {
       window.ezstandalone = window.ezstandalone || {};
-      (window.ezstandalone.cmd = window.ezstandalone.cmd || []).push(apply);
+      (window.ezstandalone.cmd = window.ezstandalone.cmd || []).push(install);
     }
   }
 
-  // ── Core ───────────────────────────────────────────────────────────────────
-
-  async function runCore() {
-    if (isBlocked()) return 0;
-    patchShowAds();
-    sweepDeadWraps();
-
-    const cfg = await fetchConfig();
-    if (!cfg || cfg.excluded) return 0;
-    initPools(cfg);
-
-    const kind = getKind();
-    if (kind === 'other') return 0;
-
-    const exec = (klass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
-      if (!normBool(cfgEnable)) return 0;
-      const interval = Math.max(1, parseInt(cfgInterval, 10) || 3);
-      return injectBetween(klass, getItems(), interval, normBool(cfgShowFirst), poolKey);
-    };
-
-    if (kind === 'topic') 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-categories', getCategories,
-      cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories'
-    );
-  }
-
-  // ── Scheduler ──────────────────────────────────────────────────────────────
-
-  function scheduleRun(cb) {
-    if (S.runQueued) return;
-    S.runQueued = true;
-    requestAnimationFrame(async () => {
-      S.runQueued = false;
-      if (S.pageKey && pageKey() !== S.pageKey) return;
-      let n = 0;
-      try { n = await runCore(); } catch (_) {}
-      try { cb?.(n); } catch (_) {}
-    });
-  }
-
-  function requestBurst() {
-    if (isBlocked()) return;
-    const t = ts();
-    if (t - S.lastBurstTs < BURST_COOLDOWN_MS) return;
-    S.lastBurstTs   = t;
-    S.pageKey       = pageKey();
-    S.burstDeadline = t + 2000;
-
-    if (S.burstActive) return;
-    S.burstActive = true;
-    S.burstCount  = 0;
-
-    const step = () => {
-      if (pageKey() !== S.pageKey || isBlocked() || ts() > S.burstDeadline || S.burstCount >= 8) {
-        S.burstActive = false; return;
+  function healFalseEmpty(root) {
+    try {
+      const list = [];
+      if (root instanceof Element && root.classList.contains(WRAP_CLASS)) list.push(root);
+      if (root?.querySelectorAll) {
+        for (const w of root.querySelectorAll(`.${WRAP_CLASS}.is-empty`)) list.push(w);
       }
-      S.burstCount++;
-      scheduleRun(n => {
-        if (!n && !S.pending.length) { S.burstActive = false; return; }
-        setTimeout(step, n > 0 ? 80 : 180);
-      });
-    };
-    step();
-  }
-
-  // ── Cleanup navigation ─────────────────────────────────────────────────────
-
-  function cleanup() {
-    blockedUntil = ts() + 1500;
-    mutate(() => document.querySelectorAll(WRAP_SEL).forEach(dropWrap));
-    S.cfg          = null;
-    S.poolsReady   = false;
-    S.pools        = { topics: [], posts: [], categories: [] };
-    S.cursors      = { topics: 0, posts: 0, categories: 0 };
-    S.mountedIds.clear();
-    S.lastShow.clear();
-    S.wrapByKey.clear();
-    S.ezActiveIds.clear();
-    S.ezShownSinceDestroy.clear();
-    S.wrapActivityAt.clear();
-    S.inflight     = 0;
-    S.pending      = [];
-    S.pendingSet.clear();
-    if (S.showBatchTimer) { clearTimeout(S.showBatchTimer); S.showBatchTimer = 0; }
-    if (S.destroyBatchTimer) { clearTimeout(S.destroyBatchTimer); S.destroyBatchTimer = 0; }
-    S.destroyPending = [];
-    S.destroyPendingSet.clear();
-    S.burstActive  = false;
-    S.runQueued    = false;
-    S.sweepQueued   = false;
-    S.scrollSpeed  = 0;
-    S.lastScrollY  = 0;
-    S.lastScrollTs = 0;
-  }
-
-  function nodeMatchesAny(node, selectors) {
-    if (!(node instanceof Element)) return false;
-    for (const sel of selectors) {
-      try { if (node.matches(sel)) return true; } catch (_) {}
-    }
-    return false;
-  }
-
-  function nodeContainsAny(node, selectors) {
-    if (!(node instanceof Element)) return false;
-    for (const sel of selectors) {
-      try { if (node.querySelector(sel)) return true; } catch (_) {}
-    }
-    return false;
+      for (const w of list) {
+        if (w.classList.contains('is-empty') && isFilled(w)) w.classList.remove('is-empty');
+      }
+    } catch (_) {}
   }
 
-  // ── MutationObserver ───────────────────────────────────────────────────────
-
-  function ensureDomObserver() {
+  function ensureObserver() {
     if (S.domObs) return;
     S.domObs = new MutationObserver(muts => {
-      if (S.mutGuard > 0 || isBlocked()) return;
+      if (S.muting > 0 || isBlocked()) return;
+      let shouldRun = false;
       for (const m of muts) {
-        let sawWrapRemoval = false;
-        for (const n of m.removedNodes) {
-          if (n.nodeType !== 1) continue;
-          if (nodeMatchesAny(n, [WRAP_SEL]) || nodeContainsAny(n, [WRAP_SEL])) {
-            sawWrapRemoval = true;
-            try {
-              if (n instanceof Element && n.classList?.contains(WRAP_CLASS)) markWrapActivity(n);
-              else if (n instanceof Element) { const inner = n.querySelector?.(WRAP_SEL); if (inner) markWrapActivity(inner); }
-            } catch (_) {}
+        for (const n of m.addedNodes) {
+          if (!(n instanceof Element)) continue;
+          healFalseEmpty(n);
+          const wrap = n.classList?.contains(WRAP_CLASS) ? n : n.querySelector?.(`.${WRAP_CLASS}`);
+          if (wrap) {
+            const id = parseInt(wrap.getAttribute(A_WRAPID), 10);
+            if (Number.isFinite(id)) {
+              const rec = ensureRegistry(id, wrap);
+              rec.lastMutationAt = now();
+              classifyWrap(rec);
+            }
+          }
+          if (n.matches?.(SEL.post) || n.matches?.(SEL.topic) || n.matches?.(SEL.category) ||
+              n.querySelector?.(SEL.post) || n.querySelector?.(SEL.topic) || n.querySelector?.(SEL.category)) {
+            shouldRun = true;
           }
         }
-        if (sawWrapRemoval) queueSweepDeadWraps();
-        for (const n of m.addedNodes) {
-          if (n.nodeType !== 1) continue;
-          try { healFalseEmpty(n); } catch (_) {}
-          try {
-            const w = (n instanceof Element && (n.classList?.contains(WRAP_CLASS) ? n : n.closest?.(WRAP_SEL))) || null;
-            if (w) markWrapActivity(w);
-            else if (n instanceof Element) { const inner = n.querySelector?.(WRAP_SEL); if (inner) markWrapActivity(inner); }
-          } catch (_) {}
-          // matches() d'abord (O(1)), querySelector() seulement si nécessaire
-          if (nodeMatchesAny(n, CONTENT_SEL_LIST) || nodeContainsAny(n, CONTENT_SEL_LIST)) {
-            requestBurst(); return;
+        for (const n of m.removedNodes) {
+          if (!(n instanceof Element)) continue;
+          if (n.classList?.contains(WRAP_CLASS) || n.querySelector?.(`.${WRAP_CLASS}`)) {
+            shouldRun = true;
           }
         }
       }
+      if (shouldRun) {
+        scheduleRun();
+        scheduleMaintenance();
+      }
     });
     try { S.domObs.observe(document.body, { childList: true, subtree: true }); } catch (_) {}
   }
 
-  // ── Utilitaires ────────────────────────────────────────────────────────────
-
   function ensureTcfLocator() {
     try {
       if (!window.__tcfapi && !window.__cmp) return;
       const inject = () => {
         if (document.getElementById('__tcfapiLocator')) return;
         const f = document.createElement('iframe');
-        f.style.display = 'none'; f.id = f.name = '__tcfapiLocator';
+        f.style.display = 'none';
+        f.id = f.name = '__tcfapiLocator';
         (document.body || document.documentElement).appendChild(f);
       };
       inject();
-      if (!window.__nbbTcfObs) {
-        window.__nbbTcfObs = new MutationObserver(inject);
-        window.__nbbTcfObs.observe(document.documentElement, { childList: true, subtree: true });
+      if (!window.__nbbTcfObsV22) {
+        window.__nbbTcfObsV22 = new MutationObserver(inject);
+        window.__nbbTcfObsV22.observe(document.documentElement, { childList: true, subtree: true });
       }
     } catch (_) {}
   }
 
-  const _warmed = new Set();
+  const warmed = new Set();
   function warmNetwork() {
     const head = document.head;
     if (!head) return;
     const frag = document.createDocumentFragment();
-    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],
+    const defs = [
+      ['preconnect', 'https://g.ezoic.net', true],
+      ['preconnect', 'https://go.ezoic.net', true],
+      ['preconnect', 'https://securepubads.g.doubleclick.net', true],
+      ['dns-prefetch', 'https://g.ezoic.net', false],
       ['dns-prefetch', 'https://securepubads.g.doubleclick.net', false],
-    ]) {
-      const k = `${rel}|${href}`;
-      if (_warmed.has(k)) continue;
-      _warmed.add(k);
+    ];
+    for (const [rel, href, cors] of defs) {
+      const key = `${rel}|${href}`;
+      if (warmed.has(key)) continue;
+      warmed.add(key);
       const l = document.createElement('link');
       l.rel = rel; l.href = href;
       if (cors) l.crossOrigin = 'anonymous';
@@ -1078,33 +712,93 @@ function startShowBatch(ids) {
     head.appendChild(frag);
   }
 
-  // ── Bindings ───────────────────────────────────────────────────────────────
+  async function runCore() {
+    if (isBlocked()) return 0;
+    patchShowAds();
+    const cfg = await fetchConfig();
+    if (!cfg || cfg.excluded) return 0;
+    initPools(cfg);
+
+    const kind = getKind();
+    if (kind === 'other') return 0;
+
+    if (kind === 'topic') {
+      if (!normBool(cfg.enableMessageAds)) return 0;
+      const interval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
+      return injectFor('ezoic-ad-message', getPosts(), interval, normBool(cfg.showFirstMessageAd));
+    }
+
+    if (kind === 'categoryTopics') {
+      if (!normBool(cfg.enableBetweenAds)) return 0;
+      const interval = Math.max(1, parseInt(cfg.intervalPosts, 10) || 3);
+      return injectFor('ezoic-ad-between', getTopics(), interval, normBool(cfg.showFirstTopicAd));
+    }
+
+    if (!normBool(cfg.enableCategoryAds)) return 0;
+    const interval = Math.max(1, parseInt(cfg.intervalCategories, 10) || 3);
+    return injectFor('ezoic-ad-categories', getCategories(), interval, normBool(cfg.showFirstCategoryAd));
+  }
+
+  function scheduleRun() {
+    if (isBlocked()) return;
+    if (S.runTimer) return;
+    S.runTimer = setTimeout(async () => {
+      S.runTimer = 0;
+      const pk = pageKey();
+      if (S.pageKey && S.pageKey !== pk) return;
+      try { await runCore(); } catch (_) {}
+      scheduleMaintenance();
+    }, CFG.runDebounceMs);
+  }
+
+  function cleanup() {
+    S.blockedUntil = now() + 1500;
+    if (S.runTimer) { clearTimeout(S.runTimer); S.runTimer = 0; }
+    if (S.showTimer) { clearTimeout(S.showTimer); S.showTimer = 0; }
+    if (S.maintenanceTimer) { clearTimeout(S.maintenanceTimer); S.maintenanceTimer = 0; }
+    mutate(() => {
+      for (const w of document.querySelectorAll(`.${WRAP_CLASS}`)) releaseWrap(w);
+    });
+    S.cfg = null;
+    S.poolsReady = false;
+    S.pools = { topics: [], posts: [], categories: [] };
+    S.cursors = { topics: 0, posts: 0, categories: 0 };
+    S.mountedIds.clear();
+    S.wrapByKey.clear();
+    S.regById.clear();
+    S.pendingShow = [];
+    S.pendingSet.clear();
+    S.lastShowById.clear();
+    S.inflightShow = 0;
+  }
 
   function bindNodeBB() {
     const $ = window.jQuery;
     if (!$) return;
-
-    $(window).off('.nbbEzoic');
-    $(window).on('action:ajaxify.start.nbbEzoic', cleanup);
-    $(window).on('action:ajaxify.end.nbbEzoic', () => {
-      S.pageKey    = pageKey();
-      blockedUntil = 0;
-      ensureTcfLocator(); warmNetwork();
-      patchShowAds(); getIO(); ensureDomObserver(); sweepDeadWraps(); requestBurst();
+    $(window).off('.nbbEzoicV22');
+    $(window).on('action:ajaxify.start.nbbEzoicV22', cleanup);
+    $(window).on('action:ajaxify.end.nbbEzoicV22', () => {
+      S.pageKey = pageKey();
+      S.blockedUntil = 0;
+      ensureTcfLocator();
+      warmNetwork();
+      patchShowAds();
+      getIO();
+      ensureObserver();
+      scheduleRun();
     });
-
-    const burstEvts = [
+    const events = [
       '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(burstEvts, () => { if (!isBlocked()) requestBurst(); });
-
+    ];
+    for (const ev of events) {
+      $(window).on(`${ev}.nbbEzoicV22`, () => { if (!isBlocked()) scheduleRun(); });
+    }
     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']) {
-          try { hooks.on(ev, () => { if (!isBlocked()) requestBurst(); }); } catch (_) {}
+        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()) scheduleRun(); }); } catch (_) {}
         }
       });
     } catch (_) {}
@@ -1112,39 +806,27 @@ function startShowBatch(ids) {
 
   function bindScroll() {
     let ticking = false;
-    try {
-      S.lastScrollY = window.scrollY || window.pageYOffset || 0;
-      S.lastScrollTs = ts();
-    } catch (_) {}
     window.addEventListener('scroll', () => {
-      try {
-        const y = window.scrollY || window.pageYOffset || 0;
-        const t = ts();
-        const dy = y - (S.lastScrollY || 0);
-        const dt = Math.max(1, t - (S.lastScrollTs || t));
-        if (Math.abs(dy) > 1) S.scrollDir = dy >= 0 ? 1 : -1;
-        const inst = Math.abs(dy) * 1000 / dt;
-        S.scrollSpeed = S.scrollSpeed ? (S.scrollSpeed * 0.7 + inst * 0.3) : inst;
-        S.lastScrollY = y;
-        S.lastScrollTs = t;
-      } catch (_) {}
       if (ticking) return;
       ticking = true;
-      requestAnimationFrame(() => { ticking = false; requestBurst(); });
+      requestAnimationFrame(() => {
+        ticking = false;
+        if (!isBlocked()) {
+          scheduleMaintenance();
+          scheduleRun();
+        }
+      });
     }, { passive: true });
   }
 
-  // ── Boot ───────────────────────────────────────────────────────────────────
-
   S.pageKey = pageKey();
   ensureTcfLocator();
   warmNetwork();
   patchShowAds();
   getIO();
-  ensureDomObserver();
+  ensureObserver();
   bindNodeBB();
   bindScroll();
-  blockedUntil = 0;
-  requestBurst();
-
+  S.blockedUntil = 0;
+  scheduleRun();
 })();