@gemx-dev/heatmap-react 3.5.92-dev.33 → 3.5.92-dev.35

package/dist/esm/index.mjs

@@ -4324,206 +4324,207 @@ function setup(doc, onChange) {
 // cspell:ignore cooldown
 /**
  * Height Observer Processor
- * Background observer — watches for iframe content height changes.
+ * Background observer — watches for iframe content height changectx.
  */
 // ── Helpers ───────────────────────────────────────────────────────────────────
-function readCurrentHeight(s) {
-    if (!s.iframe?.contentDocument || !s.iframe?.contentWindow)
+function readCurrentHeight(ctx) {
+    if (!ctx.iframe?.contentDocument || !ctx.iframe?.contentWindow)
         return 0;
-    const height = getFinalHeight(s.iframe.contentDocument, false);
-    s.logger.log('Height:', height);
+    const height = getFinalHeight(ctx.iframe.contentDocument, false);
+    ctx.logger.log('Height:', height);
     return height;
 }
-function isBlocked(s) {
-    return s.isProcessing || s.isCoolingDown || s.throttleTimeout !== null;
+function isBlocked(ctx) {
+    return ctx.isProcessing || ctx.isCoolingDown || ctx.throttleTimeout !== null;
 }
-function hasHeightChanged(s, height) {
-    return height !== s.lastHeight;
+function hasHeightChanged(ctx, height) {
+    return height !== ctx.lastHeight;
 }
 // ── Cooldown ──────────────────────────────────────────────────────────────────
-function startCooldown(s) {
-    s.isCoolingDown = true;
-    s.cooldownTimeout = setTimeout(() => {
-        s.cooldownTimeout = null;
-        s.isCoolingDown = false;
-    }, s.cooldownMs);
+function startCooldown(ctx) {
+    const cooldownMs = ctx.cooldownMs;
+    ctx.isCoolingDown = true;
+    ctx.cooldownTimeout = setTimeout(() => {
+        ctx.cooldownTimeout = null;
+        ctx.isCoolingDown = false;
+    }, cooldownMs);
 }
-function stopCooldown(s) {
-    if (s.cooldownTimeout) {
-        clearTimeout(s.cooldownTimeout);
-        s.cooldownTimeout = null;
+function stopCooldown(ctx) {
+    if (ctx.cooldownTimeout) {
+        clearTimeout(ctx.cooldownTimeout);
+        ctx.cooldownTimeout = null;
     }
-    s.isCoolingDown = false;
+    ctx.isCoolingDown = false;
 }
 // ── Debounce ──────────────────────────────────────────────────────────────────
-function cancelPendingDebounce(s) {
-    if (s.debounceTimeout) {
-        clearTimeout(s.debounceTimeout);
-        s.debounceTimeout = null;
+function cancelPendingDebounce(ctx) {
+    if (ctx.debounceTimeout) {
+        clearTimeout(ctx.debounceTimeout);
+        ctx.debounceTimeout = null;
     }
 }
-function processCurrentHeightIfChanged(s) {
-    const height = readCurrentHeight(s);
-    if (hasHeightChanged(s, height)) {
-        processHeightChange(s, height);
+function processCurrentHeightIfChanged(ctx) {
+    const height = readCurrentHeight(ctx);
+    if (hasHeightChanged(ctx, height)) {
+        processHeightChange(ctx, height);
     }
 }
-function scheduleDebounce(s) {
-    cancelPendingDebounce(s);
-    s.debounceTimeout = setTimeout(() => {
-        s.debounceTimeout = null;
-        processCurrentHeightIfChanged(s);
-    }, s.debounceMs);
+function scheduleDebounce(ctx) {
+    cancelPendingDebounce(ctx);
+    ctx.debounceTimeout = setTimeout(() => {
+        ctx.debounceTimeout = null;
+        processCurrentHeightIfChanged(ctx);
+    }, ctx.debounceMs);
 }
 // ── Throttle ──────────────────────────────────────────────────────────────────
-function scheduleThrottledCheck(s) {
-    s.throttleTimeout = setTimeout(() => {
-        s.throttleTimeout = null;
-        const height = readCurrentHeight(s);
-        if (!hasHeightChanged(s, height)) {
-            cancelPendingDebounce(s);
+function scheduleThrottledCheck(ctx) {
+    ctx.throttleTimeout = setTimeout(() => {
+        ctx.throttleTimeout = null;
+        const height = readCurrentHeight(ctx);
+        if (!hasHeightChanged(ctx, height)) {
+            cancelPendingDebounce(ctx);
             return;
         }
-        s.logger.log(`Height changed: ${s.lastHeight}px -> ${height}px`);
-        scheduleDebounce(s);
-    }, s.throttleMs);
+        ctx.logger.log(`Height changed: ${ctx.lastHeight}px -> ${height}px`);
+        scheduleDebounce(ctx);
+    }, ctx.throttleMs);
 }
 // ── Core ──────────────────────────────────────────────────────────────────────
-async function processHeightChange(s, newHeight) {
-    if (!s.iframe || !s.config)
+async function processHeightChange(ctx, newHeight) {
+    if (!ctx.iframe || !ctx.config)
         return;
-    s.isProcessing = true;
-    s.logger.log(`Processing height change: ${newHeight}px`);
+    ctx.isProcessing = true;
+    ctx.logger.log(`Processing height change: ${newHeight}px`);
     try {
         const result = {
             height: newHeight,
-            width: s.iframe.contentWindow?.innerWidth ?? 0,
+            width: ctx.iframe.contentWindow?.innerWidth ?? 0,
         };
-        s.lastHeight = newHeight;
-        s.config.onHeightChange?.(result);
+        ctx.lastHeight = newHeight;
+        ctx.config.onHeightChange?.(result);
         window.dispatchEvent(new CustomEvent('iframe-dimensions-applied', { detail: result }));
     }
     catch (error) {
-        s.logger.error('Failed to process height change:', error);
-        s.config.onError?.(error);
+        ctx.logger.error('Failed to process height change:', error);
+        ctx.config.onError?.(error);
     }
     finally {
-        s.isProcessing = false;
-        if (s.cooldownMs > 0)
-            startCooldown(s);
+        ctx.isProcessing = false;
+        if (ctx.cooldownMs > 0)
+            startCooldown(ctx);
     }
 }
-function handleHeightChange(s) {
-    if (!s.running || isBlocked(s))
+function handleHeightChange(ctx) {
+    if (!ctx.running || isBlocked(ctx))
         return;
-    scheduleThrottledCheck(s);
+    scheduleThrottledCheck(ctx);
 }
-function attachObserver(s) {
-    if (!s.iframe?.contentDocument?.body) {
-        s.logger.warn('Cannot observe height changes: iframe body not found');
+function attachObserver(ctx) {
+    if (!ctx.iframe?.contentDocument?.body) {
+        ctx.logger.warn('Cannot observe height changes: iframe body not found');
         return;
     }
-    s.observerCleanup?.();
-    const height = readCurrentHeight(s);
-    s.logger.log('Initial height:', height);
-    if (hasHeightChanged(s, height)) {
-        processHeightChange(s, height);
+    ctx.observerCleanup?.();
+    const height = readCurrentHeight(ctx);
+    ctx.logger.log('Initial height:', height);
+    if (hasHeightChanged(ctx, height)) {
+        processHeightChange(ctx, height);
     }
     else {
-        s.lastHeight = height;
+        ctx.lastHeight = height;
     }
-    s.observerCleanup = setup(s.iframe.contentDocument, () => handleHeightChange(s));
+    ctx.observerCleanup = setup(ctx.iframe.contentDocument, () => handleHeightChange(ctx));
 }
-function detachObserver(s) {
-    s.observerCleanup?.();
-    s.observerCleanup = null;
+function detachObserver(ctx) {
+    ctx.observerCleanup?.();
+    ctx.observerCleanup = null;
 }
-function clearAllTimers(s) {
-    if (s.throttleTimeout) {
-        clearTimeout(s.throttleTimeout);
-        s.throttleTimeout = null;
+function clearAllTimers(ctx) {
+    if (ctx.throttleTimeout) {
+        clearTimeout(ctx.throttleTimeout);
+        ctx.throttleTimeout = null;
     }
-    if (s.debounceTimeout) {
-        clearTimeout(s.debounceTimeout);
-        s.debounceTimeout = null;
+    if (ctx.debounceTimeout) {
+        clearTimeout(ctx.debounceTimeout);
+        ctx.debounceTimeout = null;
     }
-    if (s.startDelayTimeout) {
-        clearTimeout(s.startDelayTimeout);
-        s.startDelayTimeout = null;
+    if (ctx.startDelayTimeout) {
+        clearTimeout(ctx.startDelayTimeout);
+        ctx.startDelayTimeout = null;
     }
-    stopCooldown(s);
+    stopCooldown(ctx);
 }
 // ── Lifecycle ─────────────────────────────────────────────────────────────────
-function observeImmediately(s) {
-    attachObserver(s);
-    s.logger.log('Height observer started');
-}
-function observeAfterDelay(s, delayMs) {
-    s.logger.log(`Height observer will start in ${delayMs}ms`);
-    s.startDelayTimeout = setTimeout(() => {
-        s.startDelayTimeout = null;
-        if (!s.running)
-            return;
-        attachObserver(s);
-        s.logger.log('Height observer started (after delay)');
+function observeImmediately(ctx) {
+    attachObserver(ctx);
+    ctx.logger.log('Height observer started');
+}
+function observeAfterDelay(ctx, delayMs) {
+    ctx.logger.log(`Height observer will start in ${delayMs}ms`);
+    ctx.startDelayTimeout = setTimeout(() => {
+        ctx.startDelayTimeout = null;
+        if (!ctx.running)
+            return;
+        attachObserver(ctx);
+        ctx.logger.log('Height observer started (after delay)');
     }, delayMs);
 }
-function start$5(s, iframe, cfg) {
-    if (s.running) {
-        s.logger.warn('Observer is already running. Call stop() first.');
+function start$5(ctx, iframe, cfg) {
+    if (ctx.running) {
+        ctx.logger.warn('Observer is already running. Call stop() first.');
         return;
     }
-    s.iframe = iframe;
-    s.config = cfg;
-    s.throttleMs = cfg.throttleMs ?? 25;
-    s.debounceMs = cfg.debounceMs ?? 500;
-    s.cooldownMs = cfg.cooldownMs ?? 0;
-    s.running = true;
+    ctx.iframe = iframe;
+    ctx.config = cfg;
+    ctx.throttleMs = cfg.throttleMs ?? 25;
+    ctx.debounceMs = cfg.debounceMs ?? 500;
+    ctx.cooldownMs = cfg.cooldownMs ?? 0;
+    ctx.running = true;
     const startDelayMs = cfg.startDelayMs ?? 0;
     if (startDelayMs > 0) {
-        observeAfterDelay(s, startDelayMs);
+        observeAfterDelay(ctx, startDelayMs);
     }
     else {
-        observeImmediately(s);
+        observeImmediately(ctx);
     }
 }
-function stop$5(s) {
-    if (!s.running)
+function stop$5(ctx) {
+    if (!ctx.running)
         return;
-    detachObserver(s);
-    clearAllTimers(s);
-    s.iframe = null;
-    s.config = null;
-    s.lastHeight = 0;
-    s.isProcessing = false;
-    s.isCoolingDown = false;
-    s.running = false;
-    s.logger.log('Height observer stopped');
-}
-function clear(s) {
-    detachObserver(s);
-    clearAllTimers(s);
-    s.lastHeight = 0;
-    s.isProcessing = false;
-}
-function updateConfig$3(s, cfg) {
-    if (!s.running || !s.config) {
-        s.logger.warn('Observer is not running.');
+    detachObserver(ctx);
+    clearAllTimers(ctx);
+    ctx.iframe = null;
+    ctx.config = null;
+    ctx.lastHeight = 0;
+    ctx.isProcessing = false;
+    ctx.isCoolingDown = false;
+    ctx.running = false;
+    ctx.logger.log('Height observer stopped');
+}
+function clear(ctx) {
+    detachObserver(ctx);
+    clearAllTimers(ctx);
+    ctx.lastHeight = 0;
+    ctx.isProcessing = false;
+}
+function updateConfig$3(ctx, cfg) {
+    if (!ctx.running || !ctx.config) {
+        ctx.logger.warn('Observer is not running.');
         return;
     }
-    s.config = { ...s.config, ...cfg };
+    ctx.config = { ...ctx.config, ...cfg };
     if (cfg.throttleMs !== undefined)
-        s.throttleMs = cfg.throttleMs;
+        ctx.throttleMs = cfg.throttleMs;
     if (cfg.debounceMs !== undefined)
-        s.debounceMs = cfg.debounceMs;
+        ctx.debounceMs = cfg.debounceMs;
     if (cfg.cooldownMs !== undefined)
-        s.cooldownMs = cfg.cooldownMs;
-    s.logger.configure({ enabled: !!s.config.debug });
-    s.logger.log('Config updated');
+        ctx.cooldownMs = cfg.cooldownMs;
+    ctx.logger.configure({ enabled: !!ctx.config.debug });
+    ctx.logger.log('Config updated');
 }
 // ── Factory ───────────────────────────────────────────────────────────────────
 function createHeightObserver() {
-    const s = {
+    const ctx = {
         logger: createLogger({ enabled: true, prefix: 'IframeHeightObserver' }),
         iframe: null,
         config: null,
@@ -4541,18 +4542,18 @@ function createHeightObserver() {
         running: false,
     };
     return {
-        start: (iframe, cfg) => start$5(s, iframe, cfg),
-        stop: () => stop$5(s),
-        observe: () => attachObserver(s),
-        clear: () => clear(s),
-        updateConfig: (cfg) => updateConfig$3(s, cfg),
-        getCurrentHeight: () => s.lastHeight,
-        isRunning: () => s.running,
+        start: (iframe, cfg) => start$5(ctx, iframe, cfg),
+        stop: () => stop$5(ctx),
+        observe: () => attachObserver(ctx),
+        clear: () => clear(ctx),
+        updateConfig: (cfg) => updateConfig$3(ctx, cfg),
+        getCurrentHeight: () => ctx.lastHeight,
+        isRunning: () => ctx.running,
         getStateInfo: () => ({
-            isRunning: s.running,
-            lastHeight: s.lastHeight,
-            isProcessing: s.isProcessing,
-            hasObservers: !!s.observerCleanup,
+            isRunning: ctx.running,
+            lastHeight: ctx.lastHeight,
+            isProcessing: ctx.isProcessing,
+            hasObservers: !!ctx.observerCleanup,
         }),
     };
 }
@@ -4565,27 +4566,27 @@ function createHeightObserver() {
  *  - Dispatch navigation events to the parent window
  */
 // ── Module-level functions ────────────────────────────────────────────────────
-function attach$1(s, debug) {
-    s.logger.configure({ enabled: !!debug });
-    s.navigationBlockedListener = (e) => {
+function attach$1(ctx, debug) {
+    ctx.logger.configure({ enabled: !!debug });
+    ctx.navigationBlockedListener = (e) => {
         const ev = e;
-        s.logger.log('Navigation blocked:', ev.detail.url);
+        ctx.logger.log('Navigation blocked:', ev.detail.url);
     };
-    s.formSubmitWindowListener = (e) => {
+    ctx.formSubmitWindowListener = (e) => {
         const ev = e;
-        s.logger.log('Form submitted:', ev.detail.data);
+        ctx.logger.log('Form submitted:', ev.detail.data);
     };
-    window.addEventListener('iframe-navigation-blocked', s.navigationBlockedListener);
-    window.addEventListener('iframe-form-submit', s.formSubmitWindowListener);
+    window.addEventListener('iframe-navigation-blocked', ctx.navigationBlockedListener);
+    window.addEventListener('iframe-form-submit', ctx.formSubmitWindowListener);
 }
-function detach$1(s) {
-    if (s.navigationBlockedListener) {
-        window.removeEventListener('iframe-navigation-blocked', s.navigationBlockedListener);
-        s.navigationBlockedListener = null;
+function detach$1(ctx) {
+    if (ctx.navigationBlockedListener) {
+        window.removeEventListener('iframe-navigation-blocked', ctx.navigationBlockedListener);
+        ctx.navigationBlockedListener = null;
     }
-    if (s.formSubmitWindowListener) {
-        window.removeEventListener('iframe-form-submit', s.formSubmitWindowListener);
-        s.formSubmitWindowListener = null;
+    if (ctx.formSubmitWindowListener) {
+        window.removeEventListener('iframe-form-submit', ctx.formSubmitWindowListener);
+        ctx.formSubmitWindowListener = null;
     }
 }
 function dispatchBlocked(url, showMessage) {
@@ -4598,14 +4599,14 @@ function dispatchFormSubmit(form, data) {
 }
 // ── Factory ───────────────────────────────────────────────────────────────────
 function createNavigationListeners() {
-    const s = {
+    const ctx = {
         logger: createLogger({ enabled: false, prefix: 'IframeNavigationBlocker' }),
         navigationBlockedListener: null,
         formSubmitWindowListener: null,
     };
     return {
-        attach: (debug) => attach$1(s, debug),
-        detach: () => detach$1(s),
+        attach: (debug) => attach$1(ctx, debug),
+        detach: () => detach$1(ctx),
         dispatchBlocked,
         dispatchFormSubmit,
     };
@@ -4739,9 +4740,9 @@ function setupDOMMonitor(doc) {
  * Continuous guard — blocks all navigation attempts within the iframe.
  */
 // ── Module-level functions ────────────────────────────────────────────────────
-function start$4(s, iframe, cfg) {
-    if (s.running) {
-        s.logger.warn('Blocker is already running. Call stop() first.');
+function start$4(ctx, iframe, cfg) {
+    if (ctx.running) {
+        ctx.logger.warn('Blocker is already running. Call stop() first.');
         return;
     }
     if (!iframe.contentDocument || !iframe.contentWindow) {
@@ -4750,65 +4751,67 @@ function start$4(s, iframe, cfg) {
     const doc = iframe.contentDocument;
     const win = iframe.contentWindow;
     const originalOpen = win.open.bind(win);
-    s.logger.configure({ enabled: !!cfg?.debug });
+    ctx.logger.configure({ enabled: !!cfg?.debug });
     configure$1(!!cfg?.debug);
-    s.cleanups = [
-        setupLinkBlocker(doc, () => s.isEnabled, (url) => s.listeners.dispatchBlocked(url, s.showMessage)),
-        setupFormBlocker(doc, () => s.isEnabled, (url) => s.listeners.dispatchBlocked(url, s.showMessage), s.listeners.dispatchFormSubmit),
-        setupWindowOpenBlocker(win, originalOpen, () => s.isEnabled, (url) => s.listeners.dispatchBlocked(url, s.showMessage)),
-        setupUnloadBlocker(win, () => s.isEnabled),
-        setupDOMMonitor(doc),
-    ];
-    s.listeners.attach(cfg?.debug);
-    s.running = true;
-    s.logger.log('Started');
-}
-function stop$4(s) {
-    if (!s.running)
+    const isEnabledFn = () => ctx.isEnabled;
+    const dispatchBlocked = (url) => ctx.listeners.dispatchBlocked(url, ctx.showMessage);
+    const dispatchFormSubmit = ctx.listeners.dispatchFormSubmit;
+    const linkBlocker = setupLinkBlocker(doc, isEnabledFn, dispatchBlocked);
+    const formBlocker = setupFormBlocker(doc, isEnabledFn, dispatchBlocked, dispatchFormSubmit);
+    const windowOpenBlocker = setupWindowOpenBlocker(win, originalOpen, isEnabledFn, dispatchBlocked);
+    const unloadBlocker = setupUnloadBlocker(win, isEnabledFn);
+    const domMonitor = setupDOMMonitor(doc);
+    ctx.cleanups = [linkBlocker, formBlocker, windowOpenBlocker, unloadBlocker, domMonitor];
+    ctx.listeners.attach(cfg?.debug);
+    ctx.running = true;
+    ctx.logger.log('Started');
+}
+function stop$4(ctx) {
+    if (!ctx.running)
         return;
-    s.cleanups.forEach((fn) => fn());
-    s.cleanups = [];
-    s.listeners.detach();
-    s.isEnabled = false;
-    s.showMessage = false;
-    s.running = false;
-    s.logger.log('Stopped');
-}
-function enable(s) {
-    if (!s.running) {
-        s.logger.warn('Blocker is not running.');
+    ctx.cleanups.forEach((fn) => fn());
+    ctx.cleanups = [];
+    ctx.listeners.detach();
+    ctx.isEnabled = false;
+    ctx.showMessage = false;
+    ctx.running = false;
+    ctx.logger.log('Stopped');
+}
+function enable(ctx) {
+    if (!ctx.running) {
+        ctx.logger.warn('Blocker is not running.');
         return;
     }
-    s.isEnabled = true;
-    s.logger.log('Navigation blocking enabled');
+    ctx.isEnabled = true;
+    ctx.logger.log('Navigation blocking enabled');
 }
-function disable(s) {
-    if (!s.running) {
-        s.logger.warn('Blocker is not running.');
+function disable(ctx) {
+    if (!ctx.running) {
+        ctx.logger.warn('Blocker is not running.');
         return;
     }
-    s.isEnabled = false;
-    s.logger.log('Navigation blocking disabled');
+    ctx.isEnabled = false;
+    ctx.logger.log('Navigation blocking disabled');
 }
-function enableMessage(s) {
-    if (!s.running) {
-        s.logger.warn('Blocker is not running.');
+function enableMessage(ctx) {
+    if (!ctx.running) {
+        ctx.logger.warn('Blocker is not running.');
         return;
     }
-    s.showMessage = true;
-    s.logger.log('Navigation blocking message enabled');
+    ctx.showMessage = true;
+    ctx.logger.log('Navigation blocking message enabled');
 }
-function disableMessage(s) {
-    if (!s.running) {
-        s.logger.warn('Blocker is not running.');
+function disableMessage(ctx) {
+    if (!ctx.running) {
+        ctx.logger.warn('Blocker is not running.');
         return;
     }
-    s.showMessage = false;
-    s.logger.log('Navigation blocking message disabled');
+    ctx.showMessage = false;
+    ctx.logger.log('Navigation blocking message disabled');
 }
 // ── Factory ───────────────────────────────────────────────────────────────────
 function createNavigationBlocker() {
-    const s = {
+    const ctx = {
         logger: createLogger({ enabled: false, prefix: 'IframeNavigationBlocker' }),
         listeners: createNavigationListeners(),
         isEnabled: false,
@@ -4817,42 +4820,42 @@ function createNavigationBlocker() {
         cleanups: [],
     };
     return {
-        start: (iframe, cfg) => start$4(s, iframe, cfg),
-        stop: () => stop$4(s),
-        enable: () => enable(s),
-        disable: () => disable(s),
-        enableMessage: () => enableMessage(s),
-        disableMessage: () => disableMessage(s),
-        isRunning: () => s.running,
-        isBlockingEnabled: () => s.isEnabled,
-        getStateInfo: () => ({ isRunning: s.running, isEnabled: s.isEnabled, showMessage: s.showMessage }),
+        start: (iframe, cfg) => start$4(ctx, iframe, cfg),
+        stop: () => stop$4(ctx),
+        enable: () => enable(ctx),
+        disable: () => disable(ctx),
+        enableMessage: () => enableMessage(ctx),
+        disableMessage: () => disableMessage(ctx),
+        isRunning: () => ctx.running,
+        isBlockingEnabled: () => ctx.isEnabled,
+        getStateInfo: () => ({ isRunning: ctx.running, isEnabled: ctx.isEnabled, showMessage: ctx.showMessage }),
     };
 }
 
 // ── Module-level functions ────────────────────────────────────────────────────
-function attach(s, debug) {
-    s.logger.configure({ enabled: !!debug });
-    s.dimensionsListener = (e) => {
+function attach(ctx, debug) {
+    ctx.logger.configure({ enabled: !!debug });
+    ctx.dimensionsListener = (_e) => {
         // const ev = e as CustomEvent<IframeDimensionsDetail>;
-        // s.logger.log('Dimensions applied:', ev.detail);
+        // ctx.logger.log('Dimensions applied:', ev.detail);
     };
-    window.addEventListener('iframe-dimensions-applied', s.dimensionsListener);
+    window.addEventListener('iframe-dimensions-applied', ctx.dimensionsListener);
 }
-function detach(s) {
-    if (s.dimensionsListener) {
-        window.removeEventListener('iframe-dimensions-applied', s.dimensionsListener);
-        s.dimensionsListener = null;
+function detach(ctx) {
+    if (ctx.dimensionsListener) {
+        window.removeEventListener('iframe-dimensions-applied', ctx.dimensionsListener);
+        ctx.dimensionsListener = null;
     }
 }
 // ── Factory ───────────────────────────────────────────────────────────────────
 function createViewportListeners() {
-    const s = {
+    const ctx = {
         logger: createLogger({ enabled: false, prefix: 'ViewportReplacer' }),
         dimensionsListener: null,
     };
     return {
-        attach: (debug) => attach(s, debug),
-        detach: () => detach(s),
+        attach: (debug) => attach(ctx, debug),
+        detach: () => detach(ctx),
     };
 }
 
@@ -4896,33 +4899,33 @@ const CRITICAL_PROPERTIES = [
 ];
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
-function getViewportUnitMap(s) {
-    if (!s.config)
+function getViewportUnitMap(ctx) {
+    if (!ctx.config)
         throw new Error('Config is not initialized');
     return {
-        vh: s.config.targetHeight,
-        svh: s.config.targetHeight,
-        lvh: s.config.targetHeight,
-        dvh: s.config.targetHeight,
-        vw: s.config.targetWidth,
-        svw: s.config.targetWidth,
-        lvw: s.config.targetWidth,
-        dvw: s.config.targetWidth,
-    };
-}
-function calculateExpectedPx(s, value, unit) {
-    if (!s.config)
+        vh: ctx.config.targetHeight,
+        svh: ctx.config.targetHeight,
+        lvh: ctx.config.targetHeight,
+        dvh: ctx.config.targetHeight,
+        vw: ctx.config.targetWidth,
+        svw: ctx.config.targetWidth,
+        lvw: ctx.config.targetWidth,
+        dvw: ctx.config.targetWidth,
+    };
+}
+function calculateExpectedPx(ctx, value, unit) {
+    if (!ctx.config)
         throw new Error('Config is not initialized');
     const unitLower = unit.toLowerCase();
     if (unitLower === '%')
-        return (value / 100) * s.config.targetHeight;
-    return (value / 100) * (getViewportUnitMap(s)[unitLower] || 0);
+        return (value / 100) * ctx.config.targetHeight;
+    return (value / 100) * (getViewportUnitMap(ctx)[unitLower] || 0);
 }
 function isDefaultCssValue(value) {
     return DEFAULT_CSS_VALUES.includes(value);
 }
-function shouldReplaceValue(s, computedValue, originalValue, tolerance = DEFAULT_TOLERANCE_PX) {
-    if (!s.config)
+function shouldReplaceValue(ctx, computedValue, originalValue, tolerance = DEFAULT_TOLERANCE_PX) {
+    if (!ctx.config)
         return false;
     const computedPx = parseFloat(computedValue);
     if (isNaN(computedPx))
@@ -4935,86 +4938,86 @@ function shouldReplaceValue(s, computedValue, originalValue, tolerance = DEFAULT
     const num = parseFloat(value);
     if (isNaN(num))
         return false;
-    const expectedPx = calculateExpectedPx(s, num, unit);
+    const expectedPx = calculateExpectedPx(ctx, num, unit);
     const diff = Math.abs(computedPx - expectedPx);
     if (diff <= tolerance) {
-        s.logger.log(`OK to replace: computed=${computedValue} matches expected=${expectedPx.toFixed(2)}px (diff=${diff.toFixed(2)}px)`);
+        ctx.logger.log(`OK to replace: computed=${computedValue} matches expected=${expectedPx.toFixed(2)}px (diff=${diff.toFixed(2)}px)`);
         return true;
     }
-    s.logger.log(`Skip replace: computed=${computedValue} differs from expected=${expectedPx.toFixed(2)}px (diff=${diff.toFixed(2)}px)`);
+    ctx.logger.log(`Skip replace: computed=${computedValue} differs from expected=${expectedPx.toFixed(2)}px (diff=${diff.toFixed(2)}px)`);
     return false;
 }
-function applyPropertyWithVerification(s, element, prop, computedValue, originalValue, tolerance = DEFAULT_TOLERANCE_PX) {
-    if (originalValue && shouldReplaceValue(s, computedValue, originalValue, tolerance)) {
+function applyPropertyWithVerification(ctx, element, prop, computedValue, originalValue, tolerance = DEFAULT_TOLERANCE_PX) {
+    if (originalValue && shouldReplaceValue(ctx, computedValue, originalValue, tolerance)) {
         element.style.setProperty(prop, computedValue, 'important');
         return true;
     }
-    else if (!originalValue) {
+    if (!originalValue) {
         element.style.setProperty(prop, computedValue, 'important');
         return true;
     }
     return false;
 }
 // ── Exported module-level functions ───────────────────────────────────────────
-function start$3(s, d, w, cfg, options = {}) {
-    if (s.running) {
-        s.logger.warn('Enforcer is already running. Call stop() first.');
+function start$3(ctx, d, w, cfg, options = {}) {
+    if (ctx.running) {
+        ctx.logger.warn('Enforcer is already running. Call stop() first.');
         return;
     }
-    s.doc = d;
-    s.win = w;
-    s.config = cfg;
-    s.running = true;
-    s.logger.configure({ enabled: !!options.debug });
-    s.logger.log('Started');
+    ctx.doc = d;
+    ctx.win = w;
+    ctx.config = cfg;
+    ctx.running = true;
+    ctx.logger.configure({ enabled: !!options.debug });
+    ctx.logger.log('Started');
 }
-function stop$3(s) {
-    if (!s.running)
+function stop$3(ctx) {
+    if (!ctx.running)
         return;
-    s.doc = null;
-    s.win = null;
-    s.config = null;
-    s.elementsWithViewportUnits.clear();
-    s.originalValues = new WeakMap();
-    s.running = false;
-    s.logger.log('Stopped');
-}
-function reset(s) {
-    if (!s.running) {
-        s.logger.warn('Enforcer is not running. Call start() first.');
+    ctx.doc = null;
+    ctx.win = null;
+    ctx.config = null;
+    ctx.elementsWithViewportUnits.clear();
+    ctx.originalValues = new WeakMap();
+    ctx.running = false;
+    ctx.logger.log('Stopped');
+}
+function reset(ctx) {
+    if (!ctx.running) {
+        ctx.logger.warn('Enforcer is not running. Call start() first.');
         return;
     }
-    s.elementsWithViewportUnits.clear();
-    s.originalValues = new WeakMap();
-    s.logger.log('Reset');
+    ctx.elementsWithViewportUnits.clear();
+    ctx.originalValues = new WeakMap();
+    ctx.logger.log('Reset');
 }
-function trackElement(s, element, propertyOriginalValues) {
-    if (!s.running) {
-        s.logger.warn('Enforcer is not running. Call start() first.');
+function trackElement(ctx, element, propertyOriginalValues) {
+    if (!ctx.running) {
+        ctx.logger.warn('Enforcer is not running. Call start() first.');
         return;
     }
-    s.elementsWithViewportUnits.add(element);
-    let elementOriginals = s.originalValues.get(element);
+    ctx.elementsWithViewportUnits.add(element);
+    let elementOriginals = ctx.originalValues.get(element);
     if (!elementOriginals) {
         elementOriginals = new Map();
-        s.originalValues.set(element, elementOriginals);
+        ctx.originalValues.set(element, elementOriginals);
     }
     propertyOriginalValues.forEach((value, prop) => {
         if (!elementOriginals.has(prop))
             elementOriginals.set(prop, value);
     });
 }
-function processElement(s, element, options = {}) {
-    if (!s.running || !s.doc || !s.win || !s.config) {
-        s.logger.warn('Enforcer is not running.');
+function processElement(ctx, element, options = {}) {
+    if (!ctx.running || !ctx.doc || !ctx.win || !ctx.config) {
+        ctx.logger.warn('Enforcer is not running.');
         return 0;
     }
-    if (!s.elementsWithViewportUnits.has(element))
+    if (!ctx.elementsWithViewportUnits.has(element))
         return 0;
     const htmlElement = element;
-    const computed = s.win.getComputedStyle(htmlElement);
+    const computed = ctx.win.getComputedStyle(htmlElement);
     const inlineStyle = htmlElement.style;
-    const elementOriginals = s.originalValues.get(element);
+    const elementOriginals = ctx.originalValues.get(element);
     const tolerance = options.tolerance ?? DEFAULT_TOLERANCE_PX;
     let count = 0;
     CRITICAL_PROPERTIES.forEach((prop) => {
@@ -5022,31 +5025,31 @@ function processElement(s, element, options = {}) {
         const inlineValue = inlineStyle.getPropertyValue(prop);
         if (computedValue && (!inlineValue || inlineValue !== computedValue) && !isDefaultCssValue(computedValue)) {
             const originalValue = elementOriginals?.get(prop) || '';
-            if (applyPropertyWithVerification(s, htmlElement, prop, computedValue, originalValue, tolerance))
+            if (applyPropertyWithVerification(ctx, htmlElement, prop, computedValue, originalValue, tolerance))
                 count++;
         }
     });
     return count;
 }
-function processAll(s, options = {}) {
-    if (!s.running || !s.doc || !s.win || !s.config) {
-        s.logger.warn('Enforcer is not running.');
+function processAll(ctx, options = {}) {
+    if (!ctx.running || !ctx.doc || !ctx.win || !ctx.config) {
+        ctx.logger.warn('Enforcer is not running.');
         return 0;
     }
     let totalCount = 0;
-    s.elementsWithViewportUnits.forEach((element) => {
-        totalCount += processElement(s, element, options);
+    ctx.elementsWithViewportUnits.forEach((element) => {
+        totalCount += processElement(ctx, element, options);
     });
-    s.logger.log(`Enforced ${totalCount} computed styles for ${s.elementsWithViewportUnits.size} elements`);
+    ctx.logger.log(`Enforced ${totalCount} computed styles for ${ctx.elementsWithViewportUnits.size} elements`);
     return totalCount;
 }
-function updateConfig$2(s, cfg) {
-    if (!s.running || !s.config) {
-        s.logger.warn('Enforcer is not running.');
+function updateConfig$2(ctx, cfg) {
+    if (!ctx.running || !ctx.config) {
+        ctx.logger.warn('Enforcer is not running.');
         return;
     }
-    s.config = { ...s.config, ...cfg };
-    s.logger.log('Config updated:', cfg);
+    ctx.config = { ...ctx.config, ...cfg };
+    ctx.logger.log('Config updated:', cfg);
 }
 
 /**
@@ -5055,7 +5058,7 @@ function updateConfig$2(s, cfg) {
  */
 // ── Factory ───────────────────────────────────────────────────────────────────
 function createEnforcer() {
-    const s = {
+    const ctx = {
         logger: createLogger({ enabled: false, prefix: 'ComputedStyleEnforcer' }),
         doc: null,
         win: null,
@@ -5065,19 +5068,19 @@ function createEnforcer() {
         running: false,
     };
     return {
-        start: (d, w, cfg, options) => start$3(s, d, w, cfg, options),
-        stop: () => stop$3(s),
-        reset: () => reset(s),
-        trackElement: (element, propertyOriginalValues) => trackElement(s, element, propertyOriginalValues),
-        processElement: (element, options) => processElement(s, element, options),
-        processAll: (options) => processAll(s, options),
-        updateConfig: (cfg) => updateConfig$2(s, cfg),
+        start: (d, w, cfg, options) => start$3(ctx, d, w, cfg, options),
+        stop: () => stop$3(ctx),
+        reset: () => reset(ctx),
+        trackElement: (element, propertyOriginalValues) => trackElement(ctx, element, propertyOriginalValues),
+        processElement: (element, options) => processElement(ctx, element, options),
+        processAll: (options) => processAll(ctx, options),
+        updateConfig: (cfg) => updateConfig$2(ctx, cfg),
         getStateInfo: () => ({
-            isRunning: s.running,
-            trackedElementsCount: s.elementsWithViewportUnits.size,
-            hasConfig: !!s.config,
+            isRunning: ctx.running,
+            trackedElementsCount: ctx.elementsWithViewportUnits.size,
+            hasConfig: !!ctx.config,
         }),
-        isRunning: () => s.running,
+        isRunning: () => ctx.running,
     };
 }
 
@@ -5446,82 +5449,83 @@ register(`566240210141053597`, {
 });
 
 // ── Module-level functions ────────────────────────────────────────────────────
-function start$2(s, iframe, cfg) {
-    if (s.running) {
-        s.logger.warn('Already running. Call stop() first.');
+function start$2(ctx, iframe, cfg) {
+    if (ctx.running) {
+        ctx.logger.warn('Already running. Call stop() first.');
         return;
     }
     if (!iframe.contentDocument || !iframe.contentWindow) {
         throw new Error('Iframe document or window not accessible');
     }
-    s.doc = iframe.contentDocument;
-    s.win = iframe.contentWindow;
-    s.config = cfg;
-    s.running = true;
-    s.shopFix = cfg.shopId != null ? get(cfg.shopId) : null;
-    if (s.shopFix)
-        s.logger.log(`Shop fix loaded for "${cfg.shopId}":`, s.shopFix.description ?? '(no description)');
-    s.logger.configure({ enabled: !!cfg.debug });
+    ctx.doc = iframe.contentDocument;
+    ctx.win = iframe.contentWindow;
+    ctx.config = cfg;
+    ctx.running = true;
+    ctx.shopFix = cfg.shopId != null ? get(cfg.shopId) : null;
+    if (ctx.shopFix) {
+        ctx.logger.log(`Shop fix loaded for "${cfg.shopId}":`, ctx.shopFix.description ?? '(no description)');
+    }
+    ctx.logger.configure({ enabled: !!cfg.debug });
     configure(!!cfg.debug);
-    s.enforcer.start(s.doc, s.win, cfg, { debug: !!cfg.debug });
-    s.listeners.attach(cfg.debug);
-    s.logger.log('Started');
+    ctx.enforcer.start(ctx.doc, ctx.win, cfg, { debug: !!cfg.debug });
+    ctx.listeners.attach(cfg.debug);
+    ctx.logger.log('Started');
 }
-function stop$2(s) {
-    if (!s.running)
+function stop$2(ctx) {
+    if (!ctx.running)
         return;
-    s.enforcer.stop();
-    s.listeners.detach();
-    s.doc = null;
-    s.win = null;
-    s.config = null;
-    s.shopFix = null;
-    s.running = false;
-    s.logger.log('Stopped');
-}
-async function run(s) {
-    if (!s.running || !s.doc || !s.win || !s.config) {
-        s.logger.warn('Not running. Call start() first.');
+    ctx.enforcer.stop();
+    ctx.listeners.detach();
+    ctx.doc = null;
+    ctx.win = null;
+    ctx.config = null;
+    ctx.shopFix = null;
+    ctx.running = false;
+    ctx.logger.log('Stopped');
+}
+async function run(ctx) {
+    if (!ctx.running || !ctx.doc || !ctx.win || !ctx.config) {
+        ctx.logger.warn('Not running. Call start() first.');
         return { height: 1000, width: 1000 };
     }
-    const ctx = {
-        doc: s.doc,
-        win: s.win,
-        deviceType: s.config.deviceType,
-        targetWidth: s.config.targetWidth,
-        targetHeight: s.config.targetHeight,
-        debug: s.config.debug,
-        enforcer: s.enforcer,
-    };
-    const activeGlobal = getActiveFixes(ctx);
+    const pipelineCtx = {
+        doc: ctx.doc,
+        win: ctx.win,
+        deviceType: ctx.config.deviceType,
+        targetWidth: ctx.config.targetWidth,
+        targetHeight: ctx.config.targetHeight,
+        debug: ctx.config.debug,
+        enforcer: ctx.enforcer,
+    };
+    const activeGlobal = getActiveFixes(pipelineCtx);
     if (activeGlobal.length > 0)
-        s.logger.log(`Active global fixes: ${activeGlobal.map((f) => f.name).join(', ')}`);
+        ctx.logger.log(`Active global fixes: ${activeGlobal.map((f) => f.name).join(', ')}`);
     const tRun = perf$3.mark('viewport.run');
     try {
-        const result = await run$1(ctx, activeGlobal, s.shopFix);
+        const result = await run$1(pipelineCtx, activeGlobal, ctx.shopFix);
         perf$3.measure('viewport.run', tRun);
         return result;
     }
     catch (err) {
         perf$3.measure('viewport.run', tRun);
-        s.logger.error('Critical error:', err);
-        return { height: s.doc.body?.scrollHeight || 1000, width: s.doc.body?.scrollWidth || 1000 };
+        ctx.logger.error('Critical error:', err);
+        return { height: ctx.doc.body?.scrollHeight || 1000, width: ctx.doc.body?.scrollWidth || 1000 };
     }
 }
-function updateConfig$1(s, cfg) {
-    if (!s.running || !s.config) {
-        s.logger.warn('Not running. Call start() first.');
+function updateConfig$1(ctx, cfg) {
+    if (!ctx.running || !ctx.config) {
+        ctx.logger.warn('Not running. Call start() first.');
         return;
     }
-    s.config = { ...s.config, ...cfg };
+    ctx.config = { ...ctx.config, ...cfg };
     if (cfg.shopId !== undefined)
-        s.shopFix = cfg.shopId != null ? get(cfg.shopId) : null;
-    s.enforcer.updateConfig(cfg);
-    s.logger.log('Config updated');
+        ctx.shopFix = cfg.shopId != null ? get(cfg.shopId) : null;
+    ctx.enforcer.updateConfig(cfg);
+    ctx.logger.log('Config updated');
 }
 // ── Factory ───────────────────────────────────────────────────────────────────
 function createViewportProcessor() {
-    const s = {
+    const ctx = {
         logger: createLogger({ enabled: false, prefix: 'ViewportReplacer' }),
         enforcer: createEnforcer(),
         listeners: createViewportListeners(),
@@ -5532,11 +5536,11 @@ function createViewportProcessor() {
         running: false,
     };
     return {
-        start: (iframe, cfg) => start$2(s, iframe, cfg),
-        stop: () => stop$2(s),
-        run: () => run(s),
-        updateConfig: (cfg) => updateConfig$1(s, cfg),
-        isRunning: () => s.running,
+        start: (iframe, cfg) => start$2(ctx, iframe, cfg),
+        stop: () => stop$2(ctx),
+        run: () => run(ctx),
+        updateConfig: (cfg) => updateConfig$1(ctx, cfg),
+        isRunning: () => ctx.running,
     };
 }
 
@@ -5544,117 +5548,117 @@ function createViewportProcessor() {
 function dispatchDimensionsEvent(dimensions) {
     window.dispatchEvent(new CustomEvent('iframe-dimensions-applied', { detail: dimensions }));
 }
-async function process(s) {
-    if (!s.iframe || !s.config)
+async function process(ctx) {
+    if (!ctx.iframe || !ctx.config)
         return;
-    if (!s.iframe.contentDocument || !s.iframe.contentWindow) {
-        s.logger.error('Cannot access iframe document');
-        s.config.onError?.(new Error('Cannot access iframe document'));
+    if (!ctx.iframe.contentDocument || !ctx.iframe.contentWindow) {
+        ctx.logger.error('Cannot access iframe document');
+        ctx.config.onError?.(new Error('Cannot access iframe document'));
         return;
     }
     const sessionId = `render-${Date.now()}`;
     perf$3.startSession(sessionId);
     const t0 = perf$3.mark('orchestrator.process');
     try {
-        s.logger.groupCollapsed('Processing...');
-        s.viewportReplacer.start(s.iframe, s.config);
-        s.navigationBlocker.start(s.iframe, { debug: s.config.debug });
-        const result = await s.viewportReplacer.run();
+        ctx.logger.groupCollapsed('Processing...');
+        ctx.viewportReplacer.start(ctx.iframe, ctx.config);
+        ctx.navigationBlocker.start(ctx.iframe, { debug: ctx.config.debug });
+        const result = await ctx.viewportReplacer.run();
         perf$3.measure('orchestrator.process', t0);
         perf$3.endSession();
-        s.logger.groupEnd();
-        s.logger.log('Process completed:', result);
-        s.config.onSuccess?.(result);
+        ctx.logger.groupEnd();
+        ctx.logger.log('Process completed:', result);
+        ctx.config.onSuccess?.(result);
         dispatchDimensionsEvent(result);
     }
     catch (error) {
         perf$3.measure('orchestrator.process', t0);
         perf$3.endSession();
-        s.logger.error('Failed to process:', error);
-        s.config.onError?.(error);
+        ctx.logger.error('Failed to process:', error);
+        ctx.config.onError?.(error);
     }
 }
-async function initialize(s) {
-    if (!s.iframe || !s.config) {
-        s.logger.error('iframe not found');
-        s.config?.onError?.(new Error('iframe not found'));
+async function initialize(ctx) {
+    if (!ctx.iframe || !ctx.config) {
+        ctx.logger.error('iframe not found');
+        ctx.config?.onError?.(new Error('iframe not found'));
         return;
     }
-    if (s.iframe.contentDocument?.readyState === 'complete') {
-        await process(s);
+    if (ctx.iframe.contentDocument?.readyState === 'complete') {
+        await process(ctx);
     }
     else {
-        s.loadListener = () => process(s);
-        s.iframe.addEventListener('load', s.loadListener);
+        ctx.loadListener = () => process(ctx);
+        ctx.iframe.addEventListener('load', ctx.loadListener);
     }
 }
-function start$1(s, cfg) {
-    if (s.running) {
-        s.logger.warn('Fixer is already running. Call stop() first.');
+function start$1(ctx, cfg) {
+    if (ctx.running) {
+        ctx.logger.warn('Fixer is already running. Call stop() first.');
         return;
     }
-    s.iframe = cfg.iframe;
-    s.config = cfg;
-    s.running = true;
-    s.logger.configure({ enabled: !!cfg.debug });
-    s.logger.log('Started');
-    initialize(s);
+    ctx.iframe = cfg.iframe;
+    ctx.config = cfg;
+    ctx.running = true;
+    ctx.logger.configure({ enabled: !!cfg.debug });
+    ctx.logger.log('Started');
+    initialize(ctx);
 }
-function stop$1(s) {
-    if (!s.running)
+function stop$1(ctx) {
+    if (!ctx.running)
         return;
-    s.viewportReplacer.stop();
-    s.heightObserver.stop();
-    s.navigationBlocker.stop();
-    if (s.iframe && s.loadListener) {
-        s.iframe.removeEventListener('load', s.loadListener);
-        s.loadListener = null;
-    }
-    s.iframe = null;
-    s.config = null;
-    s.running = false;
-    s.logger.log('Stopped');
-}
-function startHeightObserver(s) {
-    if (!s.iframe || !s.config)
+    ctx.viewportReplacer.stop();
+    ctx.heightObserver.stop();
+    ctx.navigationBlocker.stop();
+    if (ctx.iframe && ctx.loadListener) {
+        ctx.iframe.removeEventListener('load', ctx.loadListener);
+        ctx.loadListener = null;
+    }
+    ctx.iframe = null;
+    ctx.config = null;
+    ctx.running = false;
+    ctx.logger.log('Stopped');
+}
+function startHeightObserver(ctx, config) {
+    if (!ctx.iframe || !ctx.config)
         return;
-    s.heightObserver.stop();
-    s.heightObserver.start(s.iframe, {
-        iframe: s.iframe,
-        debug: s.config.debug,
+    ctx.heightObserver.stop();
+    ctx.heightObserver.start(ctx.iframe, {
+        iframe: ctx.iframe,
+        debug: ctx.config.debug,
         throttleMs: 25,
         debounceMs: 500,
         cooldownMs: 1000,
-        startDelayMs: s.config.heightObserverStartDelayMs,
+        startDelayMs: ctx.config.heightObserverStartDelayMs,
         onHeightChange: (result) => {
-            s.config?.onHeightChange?.(result);
+            config?.onHeightChange?.(result);
             dispatchDimensionsEvent(result);
         },
         onError: (error) => {
-            s.config?.onError?.(error);
+            (config?.onError ?? ctx.config?.onError)?.(error);
         },
     });
 }
-async function recalculate$1(s) {
-    if (!s.running) {
-        s.logger.warn('Fixer is not running.');
+async function recalculate$1(ctx) {
+    if (!ctx.running) {
+        ctx.logger.warn('Fixer is not running.');
         return;
     }
-    s.logger.log('Recalculating...');
-    await process(s);
+    ctx.logger.log('Recalculating...');
+    await process(ctx);
 }
-function updateConfig(s, cfg) {
-    if (!s.running || !s.config) {
-        s.logger.warn('Fixer is not running.');
+function updateConfig(ctx, cfg) {
+    if (!ctx.running || !ctx.config) {
+        ctx.logger.warn('Fixer is not running.');
         return;
     }
-    s.config = { ...s.config, ...cfg };
-    s.viewportReplacer.updateConfig(cfg);
-    s.logger.log('Config updated');
+    ctx.config = { ...ctx.config, ...cfg };
+    ctx.viewportReplacer.updateConfig(cfg);
+    ctx.logger.log('Config updated');
 }
 // ── Factory ───────────────────────────────────────────────────────────────────
 function createOrchestrator() {
-    const s = {
+    const ctx = {
         logger: createLogger({ enabled: false, prefix: 'IframeFixer' }),
         viewportReplacer: createViewportProcessor(),
         navigationBlocker: createNavigationBlocker(),
@@ -5665,23 +5669,23 @@ function createOrchestrator() {
         loadListener: null,
     };
     return {
-        start: (cfg) => start$1(s, cfg),
-        stop: () => stop$1(s),
-        recalculate: () => recalculate$1(s),
-        updateConfig: (cfg) => updateConfig(s, cfg),
-        enableNavigationBlocking: () => s.navigationBlocker.enable(),
-        enableNavigationBlockingMessage: () => s.navigationBlocker.enableMessage(),
-        disableNavigationBlocking: () => s.navigationBlocker.disable(),
-        disableNavigationBlockingMessage: () => s.navigationBlocker.disableMessage(),
-        startHeightObserver: () => startHeightObserver(s),
-        isRunning: () => s.running,
+        start: (cfg) => start$1(ctx, cfg),
+        stop: () => stop$1(ctx),
+        recalculate: () => recalculate$1(ctx),
+        updateConfig: (cfg) => updateConfig(ctx, cfg),
+        enableNavigationBlocking: () => ctx.navigationBlocker.enable(),
+        enableNavigationBlockingMessage: () => ctx.navigationBlocker.enableMessage(),
+        disableNavigationBlocking: () => ctx.navigationBlocker.disable(),
+        disableNavigationBlockingMessage: () => ctx.navigationBlocker.disableMessage(),
+        startHeightObserver: (config) => startHeightObserver(ctx, config),
+        isRunning: () => ctx.running,
         getStateInfo: () => ({
-            isRunning: s.running,
-            hasIframe: !!s.iframe,
-            hasConfig: !!s.config,
-            hasNavigationBlocker: s.navigationBlocker.isRunning(),
-            hasHeightObserver: s.heightObserver.isRunning(),
-            viewportReplacerRunning: s.viewportReplacer.isRunning(),
+            isRunning: ctx.running,
+            hasIframe: !!ctx.iframe,
+            hasConfig: !!ctx.config,
+            hasNavigationBlocker: ctx.navigationBlocker.isRunning(),
+            hasHeightObserver: ctx.heightObserver.isRunning(),
+            viewportReplacerRunning: ctx.viewportReplacer.isRunning(),
         }),
     };
 }
@@ -5690,50 +5694,50 @@ function createOrchestrator() {
  * Iframe Helper — factory entry point.
  *
  * Each call to `createIframeHelper()` returns a fully isolated instance
- * with its own processor state. Use one instance per iframe.
+ * with its own processor ctx. Use one instance per iframe.
  */
 // ── Module-level functions ────────────────────────────────────────────────────
-function start(s, config) {
-    if (s.running) {
+function start(ctx, config) {
+    if (ctx.running) {
         console.warn('[IframeHelper] Already running. Call stop() first.');
         return;
     }
-    s.fixer.start(config);
-    s.running = true;
+    ctx.fixer.start(config);
+    ctx.running = true;
 }
-function stop(s) {
-    if (!s.running)
+function stop(ctx) {
+    if (!ctx.running)
         return;
-    s.fixer.stop();
-    s.running = false;
+    ctx.fixer.stop();
+    ctx.running = false;
 }
-async function recalculate(s) {
-    if (!s.running) {
+async function recalculate(ctx) {
+    if (!ctx.running) {
         console.warn('[IframeHelper] Not running. Call start() first.');
         return;
     }
-    await s.fixer.recalculate();
+    await ctx.fixer.recalculate();
 }
-function enableNavigationBlocking(s) {
-    if (!s.running) {
+function enableNavigationBlocking(ctx) {
+    if (!ctx.running) {
         console.warn('[IframeHelper] Not running. Call start() first.');
         return;
     }
-    s.fixer.enableNavigationBlocking();
+    ctx.fixer.enableNavigationBlocking();
 }
 // ── Factory ───────────────────────────────────────────────────────────────────
 function createIframeHelper() {
-    const s = {
+    const ctx = {
         fixer: createOrchestrator(),
         running: false,
     };
     return {
-        start: (config) => start(s, config),
-        stop: () => stop(s),
-        recalculate: () => recalculate(s),
-        enableNavigationBlocking: () => enableNavigationBlocking(s),
-        startHeightObserver: () => s.fixer.startHeightObserver(),
-        isRunning: () => s.running,
+        start: (config) => start(ctx, config),
+        stop: () => stop(ctx),
+        recalculate: () => recalculate(ctx),
+        enableNavigationBlocking: () => enableNavigationBlocking(ctx),
+        startHeightObserver: (config) => ctx.fixer.startHeightObserver(config),
+        isRunning: () => ctx.running,
     };
 }
 
@@ -6168,6 +6172,7 @@ class ScrollBucketRenderer {
         this.redrawTimeout = setTimeout(() => this.draw(this.lastData), REDRAW_INTERVAL);
     };
     attachDimensionsListener = () => {
+        this.detachDimensionsListener();
         this.dimensionsListener = () => this.redraw();
         window.addEventListener('iframe-dimensions-applied', this.dimensionsListener);
     };
@@ -6212,6 +6217,7 @@ class ScrollBucketRenderer {
         const doc = this.heatmap.state.window.document;
         const body = doc.body;
         const de = doc.documentElement;
+        // Same formula as HeatmapHelper.scroll() — self-contained, no external dependency
         const height = Math.max(body.scrollHeight, body.offsetHeight, de.clientHeight, de.scrollHeight, de.offsetHeight);
         // Same canvas setup as HeatmapHelper.scroll(): full content height, top=0
         canvas.height = Math.min(height, CANVAS_MAX_HEIGHT);
@@ -6220,23 +6226,32 @@ class ScrollBucketRenderer {
             return;
         const buckets = this.mapToBuckets(data);
         const maxPercent = buckets.length > 0 ? Math.max(...buckets.map((b) => b.percent)) : 0;
-        // Coldest hue (240 = blue) used as the baseline for buckets with no data
-        const coldColor = 'hsla(240, 100%, 50%, 0.6)';
-        const gradient = context.createLinearGradient(0, 0, 0, canvas.height);
-        if (buckets.length === 0 || maxPercent <= 0) {
-            // No data — fill entire canvas with the coldest color
-            gradient.addColorStop(0, coldColor);
-            gradient.addColorStop(1, coldColor);
-        }
-        else {
+        // Build a per-percentage-point hue array (same pattern as AttentionMapRenderer)
+        // Cold hue (240 = blue) is the baseline when there is no data
+        const hueStops = new Array(101).fill(240);
+        if (buckets.length > 0 && maxPercent > 0) {
+            // Pass 1: fill each bucket's pure color (exclusive of shared boundary point)
             for (const bucket of buckets) {
-                const stopMid = (bucket.startY + bucket.endY) / 2 / 100;
-                // Same hue direction as HeatmapHelper.scroll() (MaxHue = 240):
                 // high percent → hue 0 (red/hot), low percent → hue 240 (blue/cold)
-                const hue = (1 - bucket.percent / maxPercent) * 240;
-                const color = `hsla(${Math.round(hue)}, 100%, 50%, 0.6)`;
-                gradient.addColorStop(stopMid, color);
+                const hue = Math.round((1 - bucket.percent / maxPercent) * 240);
+                for (let i = bucket.startY; i < bucket.endY; i++) {
+                    hueStops[i] = hue;
+                }
             }
+            // Set last point of final bucket
+            const last = buckets[buckets.length - 1];
+            hueStops[last.endY] = Math.round((1 - last.percent / maxPercent) * 240);
+            // Pass 2: center transitions at bucket boundaries (average of two adjacent hues)
+            for (let b = 0; b < buckets.length - 1; b++) {
+                const boundary = buckets[b].endY; // = buckets[b+1].startY
+                const hueA = Math.round((1 - buckets[b].percent / maxPercent) * 240);
+                const hueB = Math.round((1 - buckets[b + 1].percent / maxPercent) * 240);
+                hueStops[boundary] = Math.round((hueA + hueB) / 2);
+            }
+        }
+        const gradient = context.createLinearGradient(0, 0, 0, canvas.height);
+        for (let i = 0; i <= 100; i++) {
+            gradient.addColorStop(i / 100, `hsla(${hueStops[i]}, 100%, 50%, 0.6)`);
         }
         context.fillStyle = gradient;
         context.fillRect(0, 0, canvas.width, canvas.height);
@@ -6245,34 +6260,19 @@ class ScrollBucketRenderer {
      * Convert flat position markers → structured buckets with startY/endY.
      *
      * Input positions: [0, 5, 10, 15, ..., 95]
-     *   position=0  → { startY: 0,  endY: 5  }  (special start marker)
-     *   position=10 → { startY: 5,  endY: 10 }
-     *   position=15 → { startY: 10, endY: 15 }
+     *   position=0  → { startY: 0,  endY: 5  }
+     *   position=5  → { startY: 5,  endY: 10 }
+     *   position=95 → { startY: 95, endY: 100 }
+     * Each position is the START of its bucket; end = next position (or 100 for last).
      */
     mapToBuckets = (data) => {
         const sorted = [...data].sort((a, b) => a.position - b.position);
-        const buckets = [];
-        for (let i = 0; i < sorted.length; i++) {
-            const current = sorted[i];
-            let startY;
-            let endY;
-            if (current.position === 0) {
-                // position=0 is the start marker → range 0 to next position
-                const next = sorted[i + 1];
-                if (!next)
-                    continue;
-                startY = 0;
-                endY = next.position;
-            }
-            else {
-                // Each non-zero position is the END of its bucket; start = previous position
-                const prev = sorted[i - 1];
-                startY = prev ? prev.position : 0;
-                endY = current.position;
-            }
-            buckets.push({ startY, endY, value: current.value, percent: current.percent });
-        }
-        return buckets;
+        return sorted.map((current, i) => ({
+            startY: current.position,
+            endY: sorted[i + 1]?.position ?? 100,
+            value: current.value,
+            percent: current.percent,
+        }));
     };
 }
 
@@ -6750,11 +6750,7 @@ const useHeatmapIframeProcessor = () => {
     const reset = useCallback(() => {
         pendingRef.current = null;
     }, []);
-    const run = useCallback((iframe, t0, abort) => {
-        if (viewport.width === 0 || viewport.height === 0) {
-            pendingRef.current = { iframe, t0, abort };
-            return;
-        }
+    const callStartIframe = useCallback((iframe, t0, abort) => {
         startIframe({
             helperRef,
             iframe,
@@ -6762,16 +6758,30 @@ const useHeatmapIframeProcessor = () => {
             deviceType,
             size: viewport,
             t0,
-            onSuccess: (height) => {
+            onSuccess: (data) => {
                 if (abort.signal.aborted)
                     return;
-                if (height)
-                    setIframeHeight(height);
+                if (data.height)
+                    setIframeHeight(data.height);
                 setIsDomLoaded(true);
-                helperRef.current?.startHeightObserver();
+                helperRef.current?.startHeightObserver({
+                    onHeightChange: (data) => {
+                        if (abort.signal.aborted)
+                            return;
+                        if (data.height)
+                            setIframeHeight(data.height);
+                    },
+                });
             },
         });
-    }, [deviceType]);
+    }, [deviceType, shopId, viewport, setIframeHeight, setIsDomLoaded]);
+    const run = useCallback((iframe, t0, abort) => {
+        if (viewport.width === 0 || viewport.height === 0) {
+            pendingRef.current = { iframe, t0, abort };
+            return;
+        }
+        callStartIframe(iframe, t0, abort);
+    }, [callStartIframe, viewport]);
     // Retry when dims become available
     useEffect(() => {
         if (viewport.width === 0 || viewport.height === 0)
@@ -6782,29 +6792,8 @@ const useHeatmapIframeProcessor = () => {
         pendingRef.current = null;
         if (abort.signal.aborted)
             return;
-        startIframe({
-            helperRef,
-            iframe,
-            shopId,
-            deviceType,
-            size: viewport,
-            t0,
-            onSuccess: (height) => {
-                if (abort.signal.aborted)
-                    return;
-                if (height)
-                    setIframeHeight(height);
-                setIsDomLoaded(true);
-                helperRef.current?.startHeightObserver();
-            },
-            onHeightChange: (height) => {
-                if (abort.signal.aborted)
-                    return;
-                if (height)
-                    setIframeHeight(height);
-            },
-        });
-    }, [viewport]); // eslint-disable-line react-hooks/exhaustive-deps
+        callStartIframe(iframe, t0, abort);
+    }, [viewport, callStartIframe]);
     useEffect(() => {
         return () => {
             helperRef.current?.stop();
@@ -6814,7 +6803,7 @@ const useHeatmapIframeProcessor = () => {
     return { run, reset };
 };
 // ── Helpers ───────────────────────────────────────────────────────────────────
-function startIframe({ helperRef, iframe, shopId, deviceType = EDeviceType.Desktop, size, t0, onSuccess, onHeightChange, }) {
+function startIframe({ helperRef, iframe, shopId, deviceType = EDeviceType.Desktop, size, t0, onSuccess, }) {
     const docWidth = size.width ?? 0;
     const docHeight = size.height ?? 0;
     if (docHeight === 0)
@@ -6835,11 +6824,7 @@ function startIframe({ helperRef, iframe, shopId, deviceType = EDeviceType.Deskt
             perf$1.measure('IframeHelper processing', tHelper);
             perf$1.measure('Total render', t0);
             iframe.style.height = `${data.height}px`;
-            onSuccess(data.height);
-        },
-        onHeightChange: (data) => {
-            iframe.style.height = `${data.height}px`;
-            onHeightChange?.(data.height);
+            onSuccess(data);
         },
     });
 }