@chordcommerce/analytics 1.23.1 → 1.25.0-beta.2

package/dist/cjs/client/index.js

@@ -63,10 +63,7 @@ var persistence_js_1 = require("./consent/persistence.js");
 var index_js_2 = require("../validators/index.js");
 var utils_js_1 = require("../utils.js");
 var DEBUG_MODE_STORAGE_KEY = 'chordcommerce/analytics/debug';
-var CONSENT_QUEUE_STORAGE_KEY = 'chordcommerce/analytics/consent-queue';
-var CONSENT_QUEUE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-var CONSENT_QUEUE_MAX_SIZE_BYTES = 100 * 1024; // 100KB max queue size
-var CONSENT_QUEUE_MAX_EVENTS = 50; // Max number of events to queue
+var OPERATION_TIMEOUT_MS = 5000;
 var ChordAnalytics = /** @class */ (function () {
     function ChordAnalytics(options) {
         var _this = this;
@@ -88,138 +85,12 @@ var ChordAnalytics = /** @class */ (function () {
          */
         this.cdpReadyPromise = null;
         this.consentConfig = null;
-        // Non-null while reset() is in flight. Acts as both the coalescing handle and
-        // the gate that track/identify/page await before executing.
-        this.resetCompletePromise = null;
-        /**
-         * Queue for events waiting for consent to be ready
-         */
-        this.consentEventQueue = [];
-        /**
-         * Whether we're currently waiting for consent and watching for it
-         */
-        this.consentWatcherActive = false;
-        /**
-         * Promise that resolves when consent is ready (shared across all queued events)
-         */
+        // Serial queue — all outgoing operations run one at a time in call order.
+        this.operationQueue = Promise.resolve();
+        // True while a reset() operation is executing in the queue.
+        this.resetting = false;
+        // Shared promise for concurrent waitForConsent() callers.
         this.consentReadyPromise = null;
-        /**
-         * Persist the consent event queue to sessionStorage for recovery on instance recreation.
-         * Validates queue size before storing to prevent QuotaExceededError.
-         */
-        this.persistQueueToStorage = function () {
-            if (typeof window === 'undefined' || !window.sessionStorage)
-                return;
-            try {
-                // Limit number of events to prevent unbounded queue growth
-                var eventsToStore = _this.consentEventQueue.slice(-CONSENT_QUEUE_MAX_EVENTS);
-                var persistedEvents = eventsToStore.map(function (item) { return ({
-                    type: item.type,
-                    args: item.args,
-                    timestamp: item.timestamp,
-                }); });
-                var serialized = JSON.stringify(persistedEvents);
-                // Check serialized size before attempting to store
-                var sizeInBytes = new Blob([serialized]).size;
-                if (sizeInBytes > CONSENT_QUEUE_MAX_SIZE_BYTES) {
-                    _this.logger("[Chord Analytics]: Consent queue too large (".concat(Math.round(sizeInBytes / 1024), "KB), skipping persistence"));
-                    return;
-                }
-                window.sessionStorage.setItem(CONSENT_QUEUE_STORAGE_KEY, serialized);
-            }
-            catch (error) {
-                _this.logger('[Chord Analytics]: Error persisting queue to storage:', error);
-            }
-        };
-        /**
-         * Restore pending events from sessionStorage (keeps events less than 5 min old).
-         * Called on new instance initialization.
-         */
-        this.restoreQueueFromStorage = function () {
-            if (typeof window === 'undefined' || !window.sessionStorage)
-                return;
-            try {
-                var stored = window.sessionStorage.getItem(CONSENT_QUEUE_STORAGE_KEY);
-                if (!stored)
-                    return;
-                var persistedEvents = void 0;
-                try {
-                    persistedEvents = JSON.parse(stored);
-                }
-                catch (parseError) {
-                    _this.logger('[Chord Analytics]: Invalid JSON in stored consent queue, clearing storage:', parseError);
-                    window.sessionStorage.removeItem(CONSENT_QUEUE_STORAGE_KEY);
-                    return;
-                }
-                // Validate that parsed data is an array
-                if (!Array.isArray(persistedEvents)) {
-                    _this.logger('[Chord Analytics]: Stored consent queue is not an array, clearing storage');
-                    window.sessionStorage.removeItem(CONSENT_QUEUE_STORAGE_KEY);
-                    return;
-                }
-                var now_1 = Date.now();
-                // Filter out expired events and events with invalid structure
-                var validEvents = persistedEvents.filter(function (event) {
-                    // Validate event structure
-                    if (typeof event !== 'object' || event === null)
-                        return false;
-                    if (!['track', 'page', 'identify'].includes(event.type))
-                        return false;
-                    if (!Array.isArray(event.args))
-                        return false;
-                    if (typeof event.timestamp !== 'number')
-                        return false;
-                    // Filter out expired events
-                    return now_1 - event.timestamp < CONSENT_QUEUE_TTL_MS;
-                });
-                if (validEvents.length === 0) {
-                    window.sessionStorage.removeItem(CONSENT_QUEUE_STORAGE_KEY);
-                    return;
-                }
-                if (_this.options.enableLogging && _this.options.debug) {
-                    // eslint-disable-next-line no-console
-                    console.log("[Chord Analytics DEBUG]: Restoring ".concat(validEvents.length, " events from sessionStorage"));
-                }
-                // Add restored events to the queue
-                validEvents.forEach(function (event) {
-                    _this.consentEventQueue.push({
-                        type: event.type,
-                        args: event.args,
-                        timestamp: event.timestamp,
-                        // eslint-disable-next-line @typescript-eslint/no-empty-function
-                        resolve: function () { },
-                    });
-                });
-                // Start watching for consent if we restored events
-                if (validEvents.length > 0 && !_this.consentWatcherActive) {
-                    _this.consentWatcherActive = true;
-                    _this.watchForConsentAndFlush();
-                }
-            }
-            catch (error) {
-                _this.logger('[Chord Analytics]: Error restoring queue from storage:', error);
-                // Clear corrupted storage
-                try {
-                    window.sessionStorage.removeItem(CONSENT_QUEUE_STORAGE_KEY);
-                }
-                catch (_a) {
-                    // Ignore cleanup errors
-                }
-            }
-        };
-        /**
-         * Clear the persisted queue from sessionStorage after successful flush.
-         */
-        this.clearQueueFromStorage = function () {
-            if (typeof window === 'undefined' || !window.sessionStorage)
-                return;
-            try {
-                window.sessionStorage.removeItem(CONSENT_QUEUE_STORAGE_KEY);
-            }
-            catch (error) {
-                _this.logger('[Chord Analytics]: Error clearing queue from storage:', error);
-            }
-        };
         /**
          * Set debug mode for Chord Analytics
          * @param enabled - Whether debug mode should be enabled
@@ -249,6 +120,32 @@ var ChordAnalytics = /** @class */ (function () {
                 return null;
             return (window === null || window === void 0 ? void 0 : window["_".concat(namespace)]) || (0, cdp_js_1.cdpQueue)(namespace);
         };
+        /*
+         * The current user and anonymous ids as the CDP knows them.
+         *
+         * Exposed to source middleware, which on Segment could read these from the
+         * event facade. Either CDP may be absent or may not implement `user()`, so
+         * every step is guarded and an unknown id is simply undefined.
+         */
+        this.currentUser = function () {
+            var read = function (analytics) {
+                var _a, _b, _c;
+                try {
+                    var user = (_a = analytics === null || analytics === void 0 ? void 0 : analytics.user) === null || _a === void 0 ? void 0 : _a.call(analytics);
+                    if (!user)
+                        return undefined;
+                    var userId = (_b = user.userId) !== null && _b !== void 0 ? _b : undefined;
+                    var anonymousId = (_c = user.anonymousId) !== null && _c !== void 0 ? _c : undefined;
+                    if (userId === undefined && anonymousId === undefined)
+                        return undefined;
+                    return { userId: userId, anonymousId: anonymousId };
+                }
+                catch (_d) {
+                    return undefined;
+                }
+            };
+            return read(_this.ccdp()) || read(_this.cdp()) || {};
+        };
         /*
          * Log a message to the console if `options.enableLogging` is true.
          */
@@ -263,21 +160,56 @@ var ChordAnalytics = /** @class */ (function () {
             console.log.apply(console, __spreadArray([message], optionalParams, false));
         };
         this.isResetting = function () {
-            return _this.resetCompletePromise !== null;
+            return _this.resetting;
+        };
+        // Enqueues an operation to run after all previously enqueued operations
+        // complete. Errors are swallowed on the internal chain so a failed operation
+        // doesn't stall the queue.
+        this.enqueue = function (operation) {
+            var queued = _this.operationQueue.then(function () { return operation(); });
+            _this.operationQueue = queued.catch(function (err) { return _this.logger(err); });
+            return queued;
+        };
+        // Wraps a CDP call with a timeout so a stuck or unresponsive CDP cannot
+        // block the queue indefinitely.
+        // eslint-disable-next-line class-methods-use-this
+        this.withTimeout = function (promise) {
+            return Promise.race([
+                promise,
+                new Promise(function (_, reject) {
+                    setTimeout(function () {
+                        return reject(new Error("CDP call timed out after ".concat(OPERATION_TIMEOUT_MS, "ms")));
+                    }, OPERATION_TIMEOUT_MS);
+                }),
+            ]);
         };
-        // Single gate for all outgoing operations. Returns a Promise only when there
-        // is actually something to wait for, preserving synchronous execution in the
-        // common case where CDP is ready and no reset is in flight.
+        // Gate for CDP readiness and consent. Reset ordering is handled by the queue.
+        // Returns undefined when nothing needs to be awaited (common case) to avoid
+        // an unnecessary microtask yield.
         this.waitForReadyState = function () {
             var cdp = _this.cdpReadyPromise;
-            var reset = _this.resetCompletePromise;
-            if (!cdp && !reset)
+            var consentPending = _this.consentConfig && !_this.consentConfig.isConsentReady();
+            if (!cdp && !consentPending)
                 return undefined;
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
-            if (cdp && reset)
-                return Promise.all([cdp, reset]).then(function () { });
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            return cdp !== null && cdp !== void 0 ? cdp : reset;
+            return (function () { return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!cdp) return [3 /*break*/, 2];
+                            return [4 /*yield*/, cdp];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2:
+                            if (!consentPending) return [3 /*break*/, 4];
+                            return [4 /*yield*/, this.waitForConsent()];
+                        case 3:
+                            _a.sent();
+                            _a.label = 4;
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            }); })();
         };
         /**
          * Wait for consent manager to be ready (no timeout - queues indefinitely).
@@ -316,107 +248,6 @@ var ChordAnalytics = /** @class */ (function () {
                 }
             });
         }); };
-        /**
-         * Queue an event to be sent when consent is ready.
-         * Persists to sessionStorage for recovery on instance recreation.
-         * Starts a consent watcher if not already active.
-         */
-        this.queueEventForConsent = function (type, args) {
-            return new Promise(function (resolve) {
-                _this.consentEventQueue.push({
-                    type: type,
-                    args: args,
-                    timestamp: Date.now(),
-                    resolve: resolve,
-                });
-                // Persist queue to sessionStorage for recovery on instance recreation
-                _this.persistQueueToStorage();
-                // Start watching for consent if not already
-                if (!_this.consentWatcherActive) {
-                    _this.consentWatcherActive = true;
-                    _this.watchForConsentAndFlush();
-                }
-            });
-        };
-        /**
-         * Watch for consent to become ready, then flush the queue.
-         */
-        this.watchForConsentAndFlush = function () { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.waitForConsent()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.flushConsentQueue()];
-                    case 2:
-                        _a.sent();
-                        this.consentWatcherActive = false;
-                        return [2 /*return*/];
-                }
-            });
-        }); };
-        /**
-         * Flush all queued events now that consent is ready.
-         * Clears sessionStorage after successful flush.
-         */
-        this.flushConsentQueue = function () { return __awaiter(_this, void 0, void 0, function () {
-            var queue, sendPromises;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        queue = __spreadArray([], this.consentEventQueue, true);
-                        this.consentEventQueue = [];
-                        // Clear persisted queue from storage since we're processing them now
-                        this.clearQueueFromStorage();
-                        if (this.options.enableLogging && this.options.debug) {
-                            // eslint-disable-next-line no-console
-                            console.log("[Chord Analytics DEBUG]: Flushing ".concat(queue.length, " queued events"));
-                        }
-                        sendPromises = queue.map(function (item) { return __awaiter(_this, void 0, void 0, function () {
-                            var _a, error_1;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        _b.trys.push([0, 9, , 10]);
-                                        _a = item.type;
-                                        switch (_a) {
-                                            case 'track': return [3 /*break*/, 1];
-                                            case 'page': return [3 /*break*/, 3];
-                                            case 'identify': return [3 /*break*/, 5];
-                                        }
-                                        return [3 /*break*/, 7];
-                                    case 1: return [4 /*yield*/, this.sendTrackEvent(item.args[0], item.args[1], item.args[2])];
-                                    case 2:
-                                        _b.sent();
-                                        return [3 /*break*/, 8];
-                                    case 3: return [4 /*yield*/, this.sendPageEvent(item.args[0], item.args[1])];
-                                    case 4:
-                                        _b.sent();
-                                        return [3 /*break*/, 8];
-                                    case 5: return [4 /*yield*/, this.sendIdentifyEvent(item.args[0], item.args[1], item.args[2])];
-                                    case 6:
-                                        _b.sent();
-                                        return [3 /*break*/, 8];
-                                    case 7: return [3 /*break*/, 8];
-                                    case 8: return [3 /*break*/, 10];
-                                    case 9:
-                                        error_1 = _b.sent();
-                                        this.logger('[Chord Analytics]: Error sending queued event:', error_1);
-                                        return [3 /*break*/, 10];
-                                    case 10:
-                                        item.resolve();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); });
-                        return [4 /*yield*/, Promise.all(sendPromises)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); };
         /**
          * Configure CDP with fresh consent categories before each event.
          * Uses Jitsu's configure() to update privacy.consentCategories.
@@ -469,85 +300,107 @@ var ChordAnalytics = /** @class */ (function () {
          * Send a `track` event to the CDP with any event name and properties.
          * If consent is not ready, the event is queued until consent is available.
          */
-        this.track = function (event, props, options) { return __awaiter(_this, void 0, void 0, function () {
-            var gate;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.options.enableLogging && this.options.debug) {
-                            // eslint-disable-next-line no-console
-                            console.log("[Chord Analytics DEBUG]: track() called with event: \"".concat(event, "\""));
-                        }
-                        if (!event)
-                            this.logger('No event name provided');
-                        gate = this.waitForReadyState();
-                        if (!gate) return [3 /*break*/, 2];
-                        return [4 /*yield*/, gate
-                            // If consent is configured but not ready, queue the event
-                        ];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        // If consent is configured but not ready, queue the event
-                        if (this.consentConfig && !this.consentConfig.isConsentReady()) {
-                            if (this.options.enableLogging && this.options.debug) {
-                                // eslint-disable-next-line no-console
-                                console.log("[Chord Analytics DEBUG]: track(\"".concat(event, "\") consent not ready, queuing event"));
-                            }
-                            return [2 /*return*/, this.queueEventForConsent('track', [event, props, options])];
-                        }
-                        if (this.options.enableLogging && this.options.debug) {
-                            // eslint-disable-next-line no-console
-                            console.log("[Chord Analytics DEBUG]: track(\"".concat(event, "\") sending event now"));
-                        }
-                        // Consent ready (or not configured) - send immediately
-                        return [2 /*return*/, this.sendTrackEvent(event, props, options)];
-                }
-            });
-        }); };
+        this.track = function (event, props, options) {
+            if (_this.options.enableLogging && _this.options.debug) {
+                // eslint-disable-next-line no-console
+                console.log("[Chord Analytics DEBUG]: track() called with event: \"".concat(event, "\""));
+            }
+            if (!event)
+                _this.logger('No event name provided');
+            return _this.enqueue(function () { return __awaiter(_this, void 0, void 0, function () {
+                var gate;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            gate = this.waitForReadyState();
+                            if (!gate) return [3 /*break*/, 2];
+                            return [4 /*yield*/, gate];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2: return [4 /*yield*/, this.sendTrackEvent(event, props, options)];
+                        case 3:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        };
         /**
          * Internal method to actually send a track event to CDP.
          */
         this.sendTrackEvent = function (event, props, options) { return __awaiter(_this, void 0, void 0, function () {
-            var formattedProps, middlewareProps, searchParams_1, urlSearchParams, searchData_1, finalEventProps;
+            var formattedProps, middlewareProps, searchParams_1, urlSearchParams, searchData_1, _a, userId_1, anonymousId_1, invoke, settle, returned, results, _b, finalEventProps, cdpPromises, a_1, b_1;
             var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         formattedProps = this.options.stripNull && props ? (0, utils_js_1.pruneNullValues)(props) : props;
                         middlewareProps = {};
-                        if (this.middleware.length > 0) {
-                            searchParams_1 = typeof window !== 'undefined' ? window.location.search : '';
-                            urlSearchParams = new URLSearchParams(searchParams_1);
-                            searchData_1 = Object.fromEntries(urlSearchParams.entries());
-                            // process middleware synchronously
-                            this.middleware.forEach(function (func) {
-                                try {
-                                    var result = func({
-                                        payload: {
-                                            obj: {
-                                                properties: props,
-                                                event: event,
-                                                context: {
-                                                    page: {
-                                                        search: searchParams_1,
-                                                        searchParams: searchData_1,
-                                                    },
+                        if (!(this.middleware.length > 0)) return [3 /*break*/, 4];
+                        searchParams_1 = typeof window !== 'undefined' ? window.location.search : '';
+                        urlSearchParams = new URLSearchParams(searchParams_1);
+                        searchData_1 = Object.fromEntries(urlSearchParams.entries());
+                        _a = this.currentUser(), userId_1 = _a.userId, anonymousId_1 = _a.anonymousId;
+                        invoke = function (func) {
+                            try {
+                                return func({
+                                    payload: {
+                                        userId: userId_1,
+                                        anonymousId: anonymousId_1,
+                                        obj: {
+                                            properties: props,
+                                            event: event,
+                                            context: {
+                                                page: {
+                                                    search: searchParams_1,
+                                                    searchParams: searchData_1,
                                                 },
                                             },
                                         },
-                                        next: function (_) { return _; },
-                                    });
-                                    if (result && typeof result === 'object') {
-                                        middlewareProps = __assign(__assign({}, middlewareProps), result);
-                                    }
-                                }
-                                catch (error) {
-                                    console.warn('Middleware error:', error);
+                                    },
+                                    next: function (_) { return _; },
+                                });
+                            }
+                            catch (error) {
+                                console.warn('Middleware error:', error);
+                                return undefined;
+                            }
+                        };
+                        settle = function (returned) {
+                            if (!(0, utils_js_1.isPromise)(returned))
+                                return returned;
+                            return (0, utils_js_1.withTimeout)(returned, utils_js_1.MIDDLEWARE_TIMEOUT_MS)
+                                .then(function (settled) {
+                                if (settled === utils_js_1.TIMED_OUT) {
+                                    console.warn("Middleware timed out after ".concat(utils_js_1.MIDDLEWARE_TIMEOUT_MS, "ms; its properties were dropped"));
+                                    return undefined;
                                 }
+                                return settled;
+                            })
+                                .catch(function (error) {
+                                console.warn('Middleware error:', error);
+                                return undefined;
                             });
-                        }
+                        };
+                        returned = this.middleware.map(invoke);
+                        if (!returned.some(utils_js_1.isPromise)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, Promise.all(returned.map(settle))];
+                    case 1:
+                        _b = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _b = returned;
+                        _c.label = 3;
+                    case 3:
+                        results = _b;
+                        results.forEach(function (result) {
+                            if (result && typeof result === 'object') {
+                                middlewareProps = __assign(__assign({}, middlewareProps), result);
+                            }
+                        });
+                        _c.label = 4;
+                    case 4:
                         finalEventProps = __assign(__assign(__assign({}, formattedProps), middlewareProps), { meta: this.meta() });
                         if (this.options.debug) {
                             this.validate(event, finalEventProps).forEach(function (valid) {
@@ -558,35 +411,27 @@ var ChordAnalytics = /** @class */ (function () {
                         }
                         // Configure CDP with fresh consent before sending
                         this.configureConsentOnCdp();
-                        return [4 /*yield*/, new Promise(function (resolve) {
-                                var cdpPromises = [];
-                                try {
-                                    var a_1 = _this.ccdp();
-                                    if (a_1 && typeof a_1.track === 'function') {
-                                        cdpPromises.push(new Promise(function (cdpResolve) {
-                                            a_1.track(event, finalEventProps, options, function () { return cdpResolve(); });
-                                        }));
-                                    }
-                                    var b_1 = _this.cdp();
-                                    if (b_1 && typeof b_1.track === 'function') {
-                                        cdpPromises.push(new Promise(function (cdpResolve) {
-                                            b_1.track(event, finalEventProps, options, function () { return cdpResolve(); });
-                                        }));
-                                    }
-                                    if (cdpPromises.length > 0) {
-                                        Promise.allSettled(cdpPromises).then(function () { return resolve(); });
-                                    }
-                                    else {
-                                        resolve();
-                                    }
-                                }
-                                catch (error) {
-                                    _this.logger(error);
-                                    resolve();
-                                }
-                            })];
-                    case 1:
-                        _a.sent();
+                        cdpPromises = [];
+                        try {
+                            a_1 = this.ccdp();
+                            if (a_1 && typeof a_1.track === 'function') {
+                                cdpPromises.push(this.withTimeout(new Promise(function (resolve) {
+                                    a_1.track(event, finalEventProps, options, function () { return resolve(); });
+                                })));
+                            }
+                            b_1 = this.cdp();
+                            if (b_1 && typeof b_1.track === 'function') {
+                                cdpPromises.push(this.withTimeout(new Promise(function (resolve) {
+                                    b_1.track(event, finalEventProps, options, function () { return resolve(); });
+                                })));
+                            }
+                        }
+                        catch (error) {
+                            this.logger(error);
+                        }
+                        return [4 /*yield*/, Promise.allSettled(cdpPromises)];
+                    case 5:
+                        _c.sent();
                         return [2 /*return*/];
                 }
             });
@@ -595,38 +440,31 @@ var ChordAnalytics = /** @class */ (function () {
          * Send an `identify` event to the CDP with user id and traits.
          * If consent is not ready, the event is queued until consent is available.
          */
-        this.identify = function (userIdOrTraits, traitsOrOptions, options) { return __awaiter(_this, void 0, void 0, function () {
-            var gate;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        gate = this.waitForReadyState();
-                        if (!gate) return [3 /*break*/, 2];
-                        return [4 /*yield*/, gate
-                            // If consent is configured but not ready, queue the event
-                        ];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        // If consent is configured but not ready, queue the event
-                        if (this.consentConfig && !this.consentConfig.isConsentReady()) {
-                            return [2 /*return*/, this.queueEventForConsent('identify', [
-                                    userIdOrTraits,
-                                    traitsOrOptions,
-                                    options,
-                                ])];
-                        }
-                        // Consent ready (or not configured) - send immediately
-                        return [2 /*return*/, this.sendIdentifyEvent(userIdOrTraits, traitsOrOptions, options)];
-                }
-            });
-        }); };
+        this.identify = function (userIdOrTraits, traitsOrOptions, options) {
+            return _this.enqueue(function () { return __awaiter(_this, void 0, void 0, function () {
+                var gate;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            gate = this.waitForReadyState();
+                            if (!gate) return [3 /*break*/, 2];
+                            return [4 /*yield*/, gate];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2: return [4 /*yield*/, this.sendIdentifyEvent(userIdOrTraits, traitsOrOptions, options)];
+                        case 3:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        };
         /**
          * Internal method to actually send an identify event to CDP.
          */
         this.sendIdentifyEvent = function (userIdOrTraits, traitsOrOptions, options) { return __awaiter(_this, void 0, void 0, function () {
-            var userId, traits, opts, identifyPromises, a_2, b_2, results, error_2;
+            var userId, traits, opts, identifyPromises, a_2, b_2, results, error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -647,25 +485,25 @@ var ChordAnalytics = /** @class */ (function () {
                         identifyPromises = [];
                         a_2 = this.ccdp();
                         if (a_2 && typeof a_2.identify === 'function') {
-                            identifyPromises.push(new Promise(function (resolve) {
+                            identifyPromises.push(this.withTimeout(new Promise(function (resolve) {
                                 if (userId) {
                                     a_2.identify(userId, traits, opts, function () { return resolve(); });
                                 }
                                 else {
                                     a_2.identify(traits, opts, function () { return resolve(); });
                                 }
-                            }));
+                            })));
                         }
                         b_2 = this.cdp();
                         if (b_2 && typeof b_2.identify === 'function') {
-                            identifyPromises.push(new Promise(function (resolve) {
+                            identifyPromises.push(this.withTimeout(new Promise(function (resolve) {
                                 if (userId) {
                                     b_2.identify(userId, traits, opts, function () { return resolve(); });
                                 }
                                 else {
                                     b_2.identify(traits, opts, function () { return resolve(); });
                                 }
-                            }));
+                            })));
                         }
                         return [4 /*yield*/, Promise.allSettled(identifyPromises)];
                     case 2:
@@ -673,8 +511,8 @@ var ChordAnalytics = /** @class */ (function () {
                         this.logger('identify event sent', results);
                         return [3 /*break*/, 4];
                     case 3:
-                        error_2 = _a.sent();
-                        this.logger(error_2);
+                        error_1 = _a.sent();
+                        this.logger(error_1);
                         return [3 /*break*/, 4];
                     case 4: return [2 /*return*/];
                 }
@@ -686,29 +524,24 @@ var ChordAnalytics = /** @class */ (function () {
          */
         this.page = function (options, props) {
             if (props === void 0) { props = {}; }
-            return __awaiter(_this, void 0, void 0, function () {
+            return _this.enqueue(function () { return __awaiter(_this, void 0, void 0, function () {
                 var gate;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
                             gate = this.waitForReadyState();
                             if (!gate) return [3 /*break*/, 2];
-                            return [4 /*yield*/, gate
-                                // If consent is configured but not ready, queue the event
-                            ];
+                            return [4 /*yield*/, gate];
                         case 1:
                             _a.sent();
                             _a.label = 2;
-                        case 2:
-                            // If consent is configured but not ready, queue the event
-                            if (this.consentConfig && !this.consentConfig.isConsentReady()) {
-                                return [2 /*return*/, this.queueEventForConsent('page', [options, props])];
-                            }
-                            // Consent ready (or not configured) - send immediately
-                            return [2 /*return*/, this.sendPageEvent(options, props)];
+                        case 2: return [4 /*yield*/, this.sendPageEvent(options, props)];
+                        case 3:
+                            _a.sent();
+                            return [2 /*return*/];
                     }
                 });
-            });
+            }); });
         };
         /**
          * Internal method to actually send a page event to CDP.
@@ -716,112 +549,96 @@ var ChordAnalytics = /** @class */ (function () {
         this.sendPageEvent = function (options, props) {
             if (props === void 0) { props = {}; }
             return __awaiter(_this, void 0, void 0, function () {
+                var pagePromises, a_3, b_3, results;
                 var _this = this;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
                             // Configure CDP with fresh consent before sending
                             this.configureConsentOnCdp();
-                            return [4 /*yield*/, new Promise(function (resolve) {
-                                    var pagePromises = [];
-                                    try {
-                                        var a_3 = _this.ccdp();
-                                        if (a_3 && typeof a_3.page === 'function') {
-                                            pagePromises.push(new Promise(function (cdpResolve) {
-                                                a_3.page(__assign(__assign({}, props), { meta: _this.meta() }), options, function () {
-                                                    return cdpResolve();
-                                                });
-                                            }));
-                                        }
-                                        var b_3 = _this.cdp();
-                                        if (b_3 && typeof b_3.page === 'function') {
-                                            pagePromises.push(new Promise(function (cdpResolve) {
-                                                b_3.page(__assign(__assign({}, props), { meta: _this.meta() }), options, function () {
-                                                    return cdpResolve();
-                                                });
-                                            }));
-                                        }
-                                        if (pagePromises.length > 0) {
-                                            Promise.allSettled(pagePromises).then(function (results) {
-                                                _this.logger('page event sent', results);
-                                                resolve();
-                                            });
-                                        }
-                                        else {
-                                            resolve();
-                                        }
-                                    }
-                                    catch (error) {
-                                        _this.logger(error);
-                                        resolve();
-                                    }
-                                })];
+                            pagePromises = [];
+                            try {
+                                // The new identity has no consent event of its own yet, so drop the
+                                // stored signature and let the next init emit a fresh baseline.
+                                (0, persistence_js_1.forgetConsent)(this.options.namespace);
+                                a_3 = this.ccdp();
+                                if (a_3 && typeof a_3.page === 'function') {
+                                    pagePromises.push(this.withTimeout(new Promise(function (resolve) {
+                                        a_3.page(__assign(__assign({}, props), { meta: _this.meta() }), options, function () { return resolve(); });
+                                    })));
+                                }
+                                b_3 = this.cdp();
+                                if (b_3 && typeof b_3.page === 'function') {
+                                    pagePromises.push(this.withTimeout(new Promise(function (resolve) {
+                                        b_3.page(__assign(__assign({}, props), { meta: _this.meta() }), options, function () { return resolve(); });
+                                    })));
+                                }
+                            }
+                            catch (error) {
+                                this.logger(error);
+                            }
+                            return [4 /*yield*/, Promise.allSettled(pagePromises)];
                         case 1:
-                            _a.sent();
+                            results = _a.sent();
+                            this.logger('page event sent', results);
                             return [2 /*return*/];
                     }
                 });
             });
         };
-        // Coalesces concurrent reset() calls — a second caller gets the same in-flight
-        // Promise rather than triggering a duplicate reset.
         this.reset = function () {
-            if (!_this.resetCompletePromise) {
-                _this.resetCompletePromise = _this.performReset();
-            }
-            return _this.resetCompletePromise;
-        };
-        this.performReset = function () { return __awaiter(_this, void 0, void 0, function () {
-            var a, b, maxAttempts, attempts, userState, error_3;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 4, 5, 6]);
-                        // The new identity has no consent event of its own yet, so drop the
-                        // stored signature and let the next init emit a fresh baseline.
-                        (0, persistence_js_1.forgetConsent)(this.options.namespace);
-                        a = this.ccdp();
-                        if (a && typeof a.reset === 'function') {
-                            a.reset();
-                        }
-                        b = this.cdp();
-                        if (b && typeof b.reset === 'function') {
-                            b.reset();
-                        }
-                        maxAttempts = 50;
-                        attempts = 0;
-                        _b.label = 1;
-                    case 1:
-                        if (!(attempts < maxAttempts)) return [3 /*break*/, 3];
-                        // eslint-disable-next-line
-                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
-                    case 2:
-                        // eslint-disable-next-line
-                        _b.sent();
-                        try {
-                            userState = ((_a = a === null || a === void 0 ? void 0 : a.user) === null || _a === void 0 ? void 0 : _a.call(a)) || {};
-                            if (userState.userId === null || userState.userId === undefined) {
-                                return [3 /*break*/, 3];
+            return _this.enqueue(function () { return __awaiter(_this, void 0, void 0, function () {
+                var a, b, maxAttempts, attempts, userState, error_2;
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            this.resetting = true;
+                            _b.label = 1;
+                        case 1:
+                            _b.trys.push([1, 5, 6, 7]);
+                            a = this.ccdp();
+                            if (a && typeof a.reset === 'function') {
+                                a.reset();
                             }
-                        }
-                        catch (_c) {
-                            return [3 /*break*/, 3];
-                        }
-                        attempts++;
-                        return [3 /*break*/, 1];
-                    case 3: return [3 /*break*/, 6];
-                    case 4:
-                        error_3 = _b.sent();
-                        this.logger(error_3);
-                        return [3 /*break*/, 6];
-                    case 5:
-                        this.resetCompletePromise = null;
-                        return [7 /*endfinally*/];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        }); };
+                            b = this.cdp();
+                            if (b && typeof b.reset === 'function') {
+                                b.reset();
+                            }
+                            maxAttempts = 50;
+                            attempts = 0;
+                            _b.label = 2;
+                        case 2:
+                            if (!(attempts < maxAttempts)) return [3 /*break*/, 4];
+                            // eslint-disable-next-line
+                            return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
+                        case 3:
+                            // eslint-disable-next-line
+                            _b.sent();
+                            try {
+                                userState = ((_a = a === null || a === void 0 ? void 0 : a.user) === null || _a === void 0 ? void 0 : _a.call(a)) || {};
+                                if (userState.userId === null || userState.userId === undefined) {
+                                    return [3 /*break*/, 4];
+                                }
+                            }
+                            catch (_c) {
+                                return [3 /*break*/, 4];
+                            }
+                            attempts++;
+                            return [3 /*break*/, 2];
+                        case 4: return [3 /*break*/, 7];
+                        case 5:
+                            error_2 = _b.sent();
+                            this.logger(error_2);
+                            return [3 /*break*/, 7];
+                        case 6:
+                            this.resetting = false;
+                            return [7 /*endfinally*/];
+                        case 7: return [2 /*return*/];
+                    }
+                });
+            }); });
+        };
         /**
          * Handler for postMessage events from the Shopify Web Pixel sandbox.
          * Bound to the instance for proper `this` context and cleanup.
@@ -1464,8 +1281,6 @@ var ChordAnalytics = /** @class */ (function () {
             var consentManager = (0, index_js_1.addCdpConsent)(this.options);
             this.consentConfig = consentManager.getConsentConfig() || null;
         }
-        // Restore any pending events from sessionStorage (survives instance recreation)
-        this.restoreQueueFromStorage();
         if (((_b = this.options) === null || _b === void 0 ? void 0 : _b.cdpDomain) && ((_c = this.options) === null || _c === void 0 ? void 0 : _c.cdpWriteKey) && window) {
             window[this.options.namespace] = (window === null || window === void 0 ? void 0 : window[this.options.namespace]) || this;
             this.initializeCdp();
@@ -1485,7 +1300,7 @@ var ChordAnalytics = /** @class */ (function () {
      */
     ChordAnalytics.prototype.initializeCdp = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var snippetPromise, initialConsent, namespace, error_4, error_5;
+            var snippetPromise, initialConsent, namespace, error_3, error_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1538,9 +1353,9 @@ var ChordAnalytics = /** @class */ (function () {
                         (0, persistence_js_1.commitConsentEmit)(namespace, initialConsent);
                         return [3 /*break*/, 6];
                     case 5:
-                        error_4 = _a.sent();
+                        error_3 = _a.sent();
                         (0, persistence_js_1.releaseConsentEmit)(namespace, initialConsent);
-                        throw error_4;
+                        throw error_3;
                     case 6:
                         if (this.options.enableLogging && this.options.debug) {
                             // eslint-disable-next-line no-console
@@ -1555,9 +1370,9 @@ var ChordAnalytics = /** @class */ (function () {
                         _a.label = 8;
                     case 8: return [3 /*break*/, 10];
                     case 9:
-                        error_5 = _a.sent();
+                        error_4 = _a.sent();
                         // eslint-disable-next-line no-console
-                        console.error('CDP initialization failed:', error_5);
+                        console.error('CDP initialization failed:', error_4);
                         return [3 /*break*/, 10];
                     case 10: return [2 /*return*/];
                 }