@tracelog/lib 0.0.7 → 0.1.0

package/dist/cjs/constants/limits.constants.d.ts

@@ -23,3 +23,5 @@ export declare const SYNC_XHR_TIMEOUT_MS = 2000;
 export declare const MAX_FINGERPRINTS = 1000;
 export declare const FINGERPRINT_CLEANUP_MULTIPLIER = 10;
 export declare const CLICK_COORDINATE_PRECISION = 10;
+export declare const MAX_RETRY_ATTEMPTS = 3;
+export declare const RETRY_DELAY_MS = 1000;

package/dist/cjs/constants/limits.constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLICK_COORDINATE_PRECISION = exports.FINGERPRINT_CLEANUP_MULTIPLIER = exports.MAX_FINGERPRINTS = exports.SYNC_XHR_TIMEOUT_MS = exports.WEB_VITALS_LONG_TASK_SAMPLING = exports.WEB_VITALS_SAMPLING = exports.PRECISION_FOUR_DECIMALS = exports.PRECISION_TWO_DECIMALS = exports.MAX_OBJECT_DEPTH = exports.MAX_ARRAY_LENGTH = exports.MAX_STRING_LENGTH = exports.MAX_TEXT_LENGTH = exports.MAX_CUSTOM_EVENT_ARRAY_SIZE = exports.MAX_CUSTOM_EVENT_KEYS = exports.MAX_CUSTOM_EVENT_STRING_SIZE = exports.MAX_CUSTOM_EVENT_NAME_LENGTH = exports.MAX_SESSION_TIMEOUT_MS = exports.MIN_SESSION_TIMEOUT_MS = exports.MAX_EVENTS_QUEUE_LENGTH = exports.BATCH_SIZE_THRESHOLD = exports.MAX_SAMPLING_RATE = exports.MIN_SAMPLING_RATE = exports.DEFAULT_SAMPLING_RATE = exports.SIGNIFICANT_SCROLL_DELTA = exports.DEFAULT_MOTION_THRESHOLD = void 0;
+exports.RETRY_DELAY_MS = exports.MAX_RETRY_ATTEMPTS = exports.CLICK_COORDINATE_PRECISION = exports.FINGERPRINT_CLEANUP_MULTIPLIER = exports.MAX_FINGERPRINTS = exports.SYNC_XHR_TIMEOUT_MS = exports.WEB_VITALS_LONG_TASK_SAMPLING = exports.WEB_VITALS_SAMPLING = exports.PRECISION_FOUR_DECIMALS = exports.PRECISION_TWO_DECIMALS = exports.MAX_OBJECT_DEPTH = exports.MAX_ARRAY_LENGTH = exports.MAX_STRING_LENGTH = exports.MAX_TEXT_LENGTH = exports.MAX_CUSTOM_EVENT_ARRAY_SIZE = exports.MAX_CUSTOM_EVENT_KEYS = exports.MAX_CUSTOM_EVENT_STRING_SIZE = exports.MAX_CUSTOM_EVENT_NAME_LENGTH = exports.MAX_SESSION_TIMEOUT_MS = exports.MIN_SESSION_TIMEOUT_MS = exports.MAX_EVENTS_QUEUE_LENGTH = exports.BATCH_SIZE_THRESHOLD = exports.MAX_SAMPLING_RATE = exports.MIN_SAMPLING_RATE = exports.DEFAULT_SAMPLING_RATE = exports.SIGNIFICANT_SCROLL_DELTA = exports.DEFAULT_MOTION_THRESHOLD = void 0;
 // Motion and interaction thresholds
 exports.DEFAULT_MOTION_THRESHOLD = 2;
 exports.SIGNIFICANT_SCROLL_DELTA = 10;
@@ -38,3 +38,6 @@ exports.MAX_FINGERPRINTS = 1000; // Maximum fingerprints stored before cleanup
 exports.FINGERPRINT_CLEANUP_MULTIPLIER = 10; // Cleanup fingerprints older than 10x threshold
 // Click coordinate precision
 exports.CLICK_COORDINATE_PRECISION = 10; // Round click coordinates to nearest 10px
+// Retry limits
+exports.MAX_RETRY_ATTEMPTS = 3;
+exports.RETRY_DELAY_MS = 1000;

package/dist/cjs/handlers/scroll.handler.d.ts

@@ -3,6 +3,9 @@ import { StateManager } from '../managers/state.manager';
 export declare class ScrollHandler extends StateManager {
     private readonly eventManager;
     private readonly containers;
+    private readonly pendingSelectors;
+    private mutationObserver;
+    private windowFallbackNeeded;
     constructor(eventManager: EventManager);
     startTracking(): void;
     stopTracking(): void;
@@ -11,6 +14,12 @@ export declare class ScrollHandler extends StateManager {
     private getScrollTop;
     private getViewportHeight;
     private getScrollHeight;
-    private isElementScrollable;
+    private getViewportWidth;
+    private getScrollWidth;
+    private hasScrollableOverflow;
     private safeQuerySelector;
+    private setupPendingSelectors;
+    private startMutationObserver;
+    private checkPendingSelectors;
+    private retryPendingSelectors;
 }

package/dist/cjs/handlers/scroll.handler.js

@@ -9,21 +9,44 @@ class ScrollHandler extends state_manager_1.StateManager {
     constructor(eventManager) {
         super();
         this.containers = [];
+        this.pendingSelectors = [];
+        this.mutationObserver = null;
+        this.windowFallbackNeeded = false;
         this.eventManager = eventManager;
     }
     startTracking() {
         const raw = this.get('config').scrollContainerSelectors;
         const selectors = Array.isArray(raw) ? raw : typeof raw === 'string' ? [raw] : [];
         logging_1.debugLog.debug('ScrollHandler', 'Starting scroll tracking', { selectorsCount: selectors.length });
-        const elements = selectors
-            .map((sel) => this.safeQuerySelector(sel))
-            .filter((element) => element instanceof HTMLElement);
-        if (elements.length === 0) {
-            elements.push(window);
+        // No custom selectors: track window immediately
+        if (selectors.length === 0) {
+            this.setupScrollContainer(window);
+            return;
         }
-        for (const element of elements) {
+        const foundElements = [];
+        const notFoundSelectors = [];
+        for (const selector of selectors) {
+            const element = this.safeQuerySelector(selector);
+            if (element instanceof HTMLElement) {
+                foundElements.push(element);
+            }
+            else if (element === null) {
+                notFoundSelectors.push(selector);
+            }
+        }
+        // Setup found elements
+        for (const element of foundElements) {
             this.setupScrollContainer(element);
         }
+        // If we have pending selectors, set up retry logic
+        if (notFoundSelectors.length > 0) {
+            this.windowFallbackNeeded = true;
+            this.setupPendingSelectors(notFoundSelectors);
+        }
+        else if (this.containers.length === 0) {
+            // No elements found and none pending: use window fallback immediately
+            this.setupScrollContainer(window);
+        }
     }
     stopTracking() {
         logging_1.debugLog.debug('ScrollHandler', 'Stopping scroll tracking', { containersCount: this.containers.length });
@@ -39,10 +62,15 @@ class ScrollHandler extends state_manager_1.StateManager {
             }
         }
         this.containers.length = 0;
+        if (this.mutationObserver) {
+            this.mutationObserver.disconnect();
+            this.mutationObserver = null;
+        }
+        this.pendingSelectors.length = 0;
     }
     setupScrollContainer(element) {
-        // Skip setup for non-scrollable elements
-        if (element !== window && !this.isElementScrollable(element)) {
+        // Skip if already tracking this element
+        if (this.containers.some((c) => c.element === element)) {
             return;
         }
         const container = {
@@ -84,9 +112,28 @@ class ScrollHandler extends state_manager_1.StateManager {
         const scrollTop = this.getScrollTop(element);
         const viewportHeight = this.getViewportHeight(element);
         const scrollHeight = this.getScrollHeight(element);
-        // Check if the page is actually scrollable at runtime
-        if (element === window && scrollHeight <= viewportHeight) {
-            return null;
+        const viewportWidth = this.getViewportWidth(element);
+        const scrollWidth = this.getScrollWidth(element);
+        // Dynamic validation: check if element is scrollable at runtime
+        if (element instanceof HTMLElement) {
+            // Check if element has scrollable overflow style (can change dynamically)
+            if (!this.hasScrollableOverflow(element)) {
+                return null;
+            }
+            // Check if content exceeds viewport (vertical OR horizontal)
+            const hasVerticalScroll = scrollHeight > viewportHeight;
+            const hasHorizontalScroll = scrollWidth > viewportWidth;
+            if (!hasVerticalScroll && !hasHorizontalScroll) {
+                return null;
+            }
+        }
+        // For Window: check if content is scrollable (vertical or horizontal)
+        if (element instanceof Window) {
+            const hasVerticalScroll = scrollHeight > viewportHeight;
+            const hasHorizontalScroll = scrollWidth > viewportWidth;
+            if (!hasVerticalScroll && !hasHorizontalScroll) {
+                return null;
+            }
         }
         const direction = scrollTop > lastScrollPos ? types_1.ScrollDirection.DOWN : types_1.ScrollDirection.UP;
         const depth = scrollHeight > viewportHeight
@@ -109,17 +156,20 @@ class ScrollHandler extends state_manager_1.StateManager {
     getScrollHeight(element) {
         return element instanceof Window ? document.documentElement.scrollHeight : element.scrollHeight;
     }
-    isElementScrollable(element) {
+    getViewportWidth(element) {
+        return element instanceof Window ? window.innerWidth : element.clientWidth;
+    }
+    getScrollWidth(element) {
+        return element instanceof Window ? document.documentElement.scrollWidth : element.scrollWidth;
+    }
+    hasScrollableOverflow(element) {
         const style = getComputedStyle(element);
-        const hasScrollableOverflow = style.overflowY === 'auto' ||
+        return (style.overflowY === 'auto' ||
             style.overflowY === 'scroll' ||
             style.overflowX === 'auto' ||
             style.overflowX === 'scroll' ||
             style.overflow === 'auto' ||
-            style.overflow === 'scroll';
-        // Element must have scrollable overflow AND content that exceeds the container
-        const hasOverflowContent = element.scrollHeight > element.clientHeight || element.scrollWidth > element.clientWidth;
-        return hasScrollableOverflow && hasOverflowContent;
+            style.overflow === 'scroll');
     }
     safeQuerySelector(selector) {
         try {
@@ -134,5 +184,95 @@ class ScrollHandler extends state_manager_1.StateManager {
             return null;
         }
     }
+    setupPendingSelectors(selectors) {
+        logging_1.debugLog.debug('ScrollHandler', 'Setting up pending selectors with retry logic', {
+            selectors,
+            maxRetries: constants_1.MAX_RETRY_ATTEMPTS,
+        });
+        for (const selector of selectors) {
+            this.pendingSelectors.push({ selector, retryCount: 0 });
+        }
+        this.startMutationObserver();
+        this.retryPendingSelectors();
+    }
+    startMutationObserver() {
+        if (this.mutationObserver)
+            return;
+        this.mutationObserver = new MutationObserver(() => {
+            this.checkPendingSelectors();
+        });
+        this.mutationObserver.observe(document.body, {
+            childList: true,
+            subtree: true,
+        });
+        logging_1.debugLog.debug('ScrollHandler', 'MutationObserver started for pending selectors');
+    }
+    checkPendingSelectors() {
+        const remaining = [];
+        for (const pending of this.pendingSelectors) {
+            const element = this.safeQuerySelector(pending.selector);
+            if (element instanceof HTMLElement) {
+                logging_1.debugLog.debug('ScrollHandler', 'Found pending selector', { selector: pending.selector });
+                this.setupScrollContainer(element);
+            }
+            else {
+                remaining.push(pending);
+            }
+        }
+        this.pendingSelectors.length = 0;
+        this.pendingSelectors.push(...remaining);
+        if (this.pendingSelectors.length === 0 && this.mutationObserver) {
+            this.mutationObserver.disconnect();
+            this.mutationObserver = null;
+            logging_1.debugLog.debug('ScrollHandler', 'All pending selectors resolved, MutationObserver stopped');
+        }
+    }
+    retryPendingSelectors() {
+        setTimeout(() => {
+            if (this.pendingSelectors.length === 0)
+                return;
+            const remaining = [];
+            for (const pending of this.pendingSelectors) {
+                pending.retryCount++;
+                const element = this.safeQuerySelector(pending.selector);
+                if (element instanceof HTMLElement) {
+                    logging_1.debugLog.debug('ScrollHandler', 'Retry found pending selector', {
+                        selector: pending.selector,
+                        retryCount: pending.retryCount,
+                    });
+                    this.setupScrollContainer(element);
+                }
+                else if (pending.retryCount < constants_1.MAX_RETRY_ATTEMPTS) {
+                    remaining.push(pending);
+                }
+                else {
+                    logging_1.debugLog.clientWarn('ScrollHandler', 'Selector not found after max retries', {
+                        selector: pending.selector,
+                        maxRetries: constants_1.MAX_RETRY_ATTEMPTS,
+                    });
+                }
+            }
+            this.pendingSelectors.length = 0;
+            this.pendingSelectors.push(...remaining);
+            if (this.pendingSelectors.length > 0) {
+                this.retryPendingSelectors();
+            }
+            else {
+                // All retries complete
+                if (this.mutationObserver) {
+                    this.mutationObserver.disconnect();
+                    this.mutationObserver = null;
+                }
+                // Apply window fallback if needed and no containers were set up
+                if (this.windowFallbackNeeded && this.containers.length === 0) {
+                    logging_1.debugLog.debug('ScrollHandler', 'No scroll containers found, using window fallback');
+                    this.setupScrollContainer(window);
+                }
+                logging_1.debugLog.debug('ScrollHandler', 'All pending selectors resolved or timed out', {
+                    containersCount: this.containers.length,
+                });
+            }
+        }, constants_1.RETRY_DELAY_MS);
+    }
 }
 exports.ScrollHandler = ScrollHandler;

package/dist/cjs/managers/sender.manager.js

@@ -87,7 +87,7 @@ class SenderManager extends state_manager_1.StateManager {
             const response = await fetch(url, {
                 method: 'POST',
                 mode: 'cors',
-                credentials: 'omit',
+                credentials: 'include',
                 body: payload,
                 headers: {
                     'Content-Type': 'application/json',
@@ -131,7 +131,7 @@ class SenderManager extends state_manager_1.StateManager {
             xhr.setRequestHeader('Content-Type', 'application/json');
             xhr.setRequestHeader('Origin', window.location.origin);
             xhr.setRequestHeader('Referer', window.location.href);
-            xhr.withCredentials = false;
+            xhr.withCredentials = true;
             xhr.timeout = constants_1.SYNC_XHR_TIMEOUT_MS;
             xhr.send(payload);
             return xhr.status >= 200 && xhr.status < 300;

package/dist/esm/constants/limits.constants.d.ts

@@ -23,3 +23,5 @@ export declare const SYNC_XHR_TIMEOUT_MS = 2000;
 export declare const MAX_FINGERPRINTS = 1000;
 export declare const FINGERPRINT_CLEANUP_MULTIPLIER = 10;
 export declare const CLICK_COORDINATE_PRECISION = 10;
+export declare const MAX_RETRY_ATTEMPTS = 3;
+export declare const RETRY_DELAY_MS = 1000;

package/dist/esm/constants/limits.constants.js

@@ -35,3 +35,6 @@ export const MAX_FINGERPRINTS = 1000; // Maximum fingerprints stored before clea
 export const FINGERPRINT_CLEANUP_MULTIPLIER = 10; // Cleanup fingerprints older than 10x threshold
 // Click coordinate precision
 export const CLICK_COORDINATE_PRECISION = 10; // Round click coordinates to nearest 10px
+// Retry limits
+export const MAX_RETRY_ATTEMPTS = 3;
+export const RETRY_DELAY_MS = 1000;

package/dist/esm/handlers/scroll.handler.d.ts

@@ -3,6 +3,9 @@ import { StateManager } from '../managers/state.manager';
 export declare class ScrollHandler extends StateManager {
     private readonly eventManager;
     private readonly containers;
+    private readonly pendingSelectors;
+    private mutationObserver;
+    private windowFallbackNeeded;
     constructor(eventManager: EventManager);
     startTracking(): void;
     stopTracking(): void;
@@ -11,6 +14,12 @@ export declare class ScrollHandler extends StateManager {
     private getScrollTop;
     private getViewportHeight;
     private getScrollHeight;
-    private isElementScrollable;
+    private getViewportWidth;
+    private getScrollWidth;
+    private hasScrollableOverflow;
     private safeQuerySelector;
+    private setupPendingSelectors;
+    private startMutationObserver;
+    private checkPendingSelectors;
+    private retryPendingSelectors;
 }

package/dist/esm/handlers/scroll.handler.js

@@ -1,4 +1,4 @@
-import { SCROLL_DEBOUNCE_TIME_MS, SIGNIFICANT_SCROLL_DELTA } from '../constants';
+import { MAX_RETRY_ATTEMPTS, RETRY_DELAY_MS, SCROLL_DEBOUNCE_TIME_MS, SIGNIFICANT_SCROLL_DELTA } from '../constants';
 import { EventType, ScrollDirection } from '../types';
 import { StateManager } from '../managers/state.manager';
 import { debugLog } from '../utils/logging';
@@ -6,21 +6,44 @@ export class ScrollHandler extends StateManager {
     constructor(eventManager) {
         super();
         this.containers = [];
+        this.pendingSelectors = [];
+        this.mutationObserver = null;
+        this.windowFallbackNeeded = false;
         this.eventManager = eventManager;
     }
     startTracking() {
         const raw = this.get('config').scrollContainerSelectors;
         const selectors = Array.isArray(raw) ? raw : typeof raw === 'string' ? [raw] : [];
         debugLog.debug('ScrollHandler', 'Starting scroll tracking', { selectorsCount: selectors.length });
-        const elements = selectors
-            .map((sel) => this.safeQuerySelector(sel))
-            .filter((element) => element instanceof HTMLElement);
-        if (elements.length === 0) {
-            elements.push(window);
+        // No custom selectors: track window immediately
+        if (selectors.length === 0) {
+            this.setupScrollContainer(window);
+            return;
         }
-        for (const element of elements) {
+        const foundElements = [];
+        const notFoundSelectors = [];
+        for (const selector of selectors) {
+            const element = this.safeQuerySelector(selector);
+            if (element instanceof HTMLElement) {
+                foundElements.push(element);
+            }
+            else if (element === null) {
+                notFoundSelectors.push(selector);
+            }
+        }
+        // Setup found elements
+        for (const element of foundElements) {
             this.setupScrollContainer(element);
         }
+        // If we have pending selectors, set up retry logic
+        if (notFoundSelectors.length > 0) {
+            this.windowFallbackNeeded = true;
+            this.setupPendingSelectors(notFoundSelectors);
+        }
+        else if (this.containers.length === 0) {
+            // No elements found and none pending: use window fallback immediately
+            this.setupScrollContainer(window);
+        }
     }
     stopTracking() {
         debugLog.debug('ScrollHandler', 'Stopping scroll tracking', { containersCount: this.containers.length });
@@ -36,10 +59,15 @@ export class ScrollHandler extends StateManager {
             }
         }
         this.containers.length = 0;
+        if (this.mutationObserver) {
+            this.mutationObserver.disconnect();
+            this.mutationObserver = null;
+        }
+        this.pendingSelectors.length = 0;
     }
     setupScrollContainer(element) {
-        // Skip setup for non-scrollable elements
-        if (element !== window && !this.isElementScrollable(element)) {
+        // Skip if already tracking this element
+        if (this.containers.some((c) => c.element === element)) {
             return;
         }
         const container = {
@@ -81,9 +109,28 @@ export class ScrollHandler extends StateManager {
         const scrollTop = this.getScrollTop(element);
         const viewportHeight = this.getViewportHeight(element);
         const scrollHeight = this.getScrollHeight(element);
-        // Check if the page is actually scrollable at runtime
-        if (element === window && scrollHeight <= viewportHeight) {
-            return null;
+        const viewportWidth = this.getViewportWidth(element);
+        const scrollWidth = this.getScrollWidth(element);
+        // Dynamic validation: check if element is scrollable at runtime
+        if (element instanceof HTMLElement) {
+            // Check if element has scrollable overflow style (can change dynamically)
+            if (!this.hasScrollableOverflow(element)) {
+                return null;
+            }
+            // Check if content exceeds viewport (vertical OR horizontal)
+            const hasVerticalScroll = scrollHeight > viewportHeight;
+            const hasHorizontalScroll = scrollWidth > viewportWidth;
+            if (!hasVerticalScroll && !hasHorizontalScroll) {
+                return null;
+            }
+        }
+        // For Window: check if content is scrollable (vertical or horizontal)
+        if (element instanceof Window) {
+            const hasVerticalScroll = scrollHeight > viewportHeight;
+            const hasHorizontalScroll = scrollWidth > viewportWidth;
+            if (!hasVerticalScroll && !hasHorizontalScroll) {
+                return null;
+            }
         }
         const direction = scrollTop > lastScrollPos ? ScrollDirection.DOWN : ScrollDirection.UP;
         const depth = scrollHeight > viewportHeight
@@ -106,17 +153,20 @@ export class ScrollHandler extends StateManager {
     getScrollHeight(element) {
         return element instanceof Window ? document.documentElement.scrollHeight : element.scrollHeight;
     }
-    isElementScrollable(element) {
+    getViewportWidth(element) {
+        return element instanceof Window ? window.innerWidth : element.clientWidth;
+    }
+    getScrollWidth(element) {
+        return element instanceof Window ? document.documentElement.scrollWidth : element.scrollWidth;
+    }
+    hasScrollableOverflow(element) {
         const style = getComputedStyle(element);
-        const hasScrollableOverflow = style.overflowY === 'auto' ||
+        return (style.overflowY === 'auto' ||
             style.overflowY === 'scroll' ||
             style.overflowX === 'auto' ||
             style.overflowX === 'scroll' ||
             style.overflow === 'auto' ||
-            style.overflow === 'scroll';
-        // Element must have scrollable overflow AND content that exceeds the container
-        const hasOverflowContent = element.scrollHeight > element.clientHeight || element.scrollWidth > element.clientWidth;
-        return hasScrollableOverflow && hasOverflowContent;
+            style.overflow === 'scroll');
     }
     safeQuerySelector(selector) {
         try {
@@ -131,4 +181,94 @@ export class ScrollHandler extends StateManager {
             return null;
         }
     }
+    setupPendingSelectors(selectors) {
+        debugLog.debug('ScrollHandler', 'Setting up pending selectors with retry logic', {
+            selectors,
+            maxRetries: MAX_RETRY_ATTEMPTS,
+        });
+        for (const selector of selectors) {
+            this.pendingSelectors.push({ selector, retryCount: 0 });
+        }
+        this.startMutationObserver();
+        this.retryPendingSelectors();
+    }
+    startMutationObserver() {
+        if (this.mutationObserver)
+            return;
+        this.mutationObserver = new MutationObserver(() => {
+            this.checkPendingSelectors();
+        });
+        this.mutationObserver.observe(document.body, {
+            childList: true,
+            subtree: true,
+        });
+        debugLog.debug('ScrollHandler', 'MutationObserver started for pending selectors');
+    }
+    checkPendingSelectors() {
+        const remaining = [];
+        for (const pending of this.pendingSelectors) {
+            const element = this.safeQuerySelector(pending.selector);
+            if (element instanceof HTMLElement) {
+                debugLog.debug('ScrollHandler', 'Found pending selector', { selector: pending.selector });
+                this.setupScrollContainer(element);
+            }
+            else {
+                remaining.push(pending);
+            }
+        }
+        this.pendingSelectors.length = 0;
+        this.pendingSelectors.push(...remaining);
+        if (this.pendingSelectors.length === 0 && this.mutationObserver) {
+            this.mutationObserver.disconnect();
+            this.mutationObserver = null;
+            debugLog.debug('ScrollHandler', 'All pending selectors resolved, MutationObserver stopped');
+        }
+    }
+    retryPendingSelectors() {
+        setTimeout(() => {
+            if (this.pendingSelectors.length === 0)
+                return;
+            const remaining = [];
+            for (const pending of this.pendingSelectors) {
+                pending.retryCount++;
+                const element = this.safeQuerySelector(pending.selector);
+                if (element instanceof HTMLElement) {
+                    debugLog.debug('ScrollHandler', 'Retry found pending selector', {
+                        selector: pending.selector,
+                        retryCount: pending.retryCount,
+                    });
+                    this.setupScrollContainer(element);
+                }
+                else if (pending.retryCount < MAX_RETRY_ATTEMPTS) {
+                    remaining.push(pending);
+                }
+                else {
+                    debugLog.clientWarn('ScrollHandler', 'Selector not found after max retries', {
+                        selector: pending.selector,
+                        maxRetries: MAX_RETRY_ATTEMPTS,
+                    });
+                }
+            }
+            this.pendingSelectors.length = 0;
+            this.pendingSelectors.push(...remaining);
+            if (this.pendingSelectors.length > 0) {
+                this.retryPendingSelectors();
+            }
+            else {
+                // All retries complete
+                if (this.mutationObserver) {
+                    this.mutationObserver.disconnect();
+                    this.mutationObserver = null;
+                }
+                // Apply window fallback if needed and no containers were set up
+                if (this.windowFallbackNeeded && this.containers.length === 0) {
+                    debugLog.debug('ScrollHandler', 'No scroll containers found, using window fallback');
+                    this.setupScrollContainer(window);
+                }
+                debugLog.debug('ScrollHandler', 'All pending selectors resolved or timed out', {
+                    containersCount: this.containers.length,
+                });
+            }
+        }, RETRY_DELAY_MS);
+    }
 }

package/dist/esm/managers/sender.manager.js

@@ -84,7 +84,7 @@ export class SenderManager extends StateManager {
             const response = await fetch(url, {
                 method: 'POST',
                 mode: 'cors',
-                credentials: 'omit',
+                credentials: 'include',
                 body: payload,
                 headers: {
                     'Content-Type': 'application/json',
@@ -128,7 +128,7 @@ export class SenderManager extends StateManager {
             xhr.setRequestHeader('Content-Type', 'application/json');
             xhr.setRequestHeader('Origin', window.location.origin);
             xhr.setRequestHeader('Referer', window.location.href);
-            xhr.withCredentials = false;
+            xhr.withCredentials = true;
             xhr.timeout = SYNC_XHR_TIMEOUT_MS;
             xhr.send(payload);
             return xhr.status >= 200 && xhr.status < 300;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tracelog/lib",
   "description": "JavaScript library for web analytics and real-time event tracking",
   "license": "MIT",
-  "version": "0.0.7",
+  "version": "0.1.0",
   "main": "./dist/cjs/public-api.js",
   "module": "./dist/esm/public-api.js",
   "types": "./dist/esm/public-api.d.ts",