@contentful/optimization-core 0.1.0-alpha → 0.1.0-alpha10

package/dist/index.cjs

@@ -1,1804 +1,1992 @@
 "use strict";
 var __webpack_modules__ = {
-    "./src/CoreBase.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+    "./src/constants.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            A: ()=>__rspack_default_export
+            ANONYMOUS_ID_COOKIE: ()=>ANONYMOUS_ID_COOKIE,
+            ANONYMOUS_ID_COOKIE_LEGACY: ()=>ANONYMOUS_ID_COOKIE_LEGACY,
+            ANONYMOUS_ID_KEY: ()=>ANONYMOUS_ID_KEY,
+            ANONYMOUS_ID_KEY_LEGACY: ()=>ANONYMOUS_ID_KEY_LEGACY,
+            CHANGES_CACHE_KEY: ()=>CHANGES_CACHE_KEY,
+            CONSENT_KEY: ()=>CONSENT_KEY,
+            DEBUG_FLAG_KEY: ()=>DEBUG_FLAG_KEY,
+            OPTIMIZATION_CORE_SDK_NAME: ()=>OPTIMIZATION_CORE_SDK_NAME,
+            OPTIMIZATION_CORE_SDK_VERSION: ()=>OPTIMIZATION_CORE_SDK_VERSION,
+            PERSONALIZATIONS_CACHE_KEY: ()=>PERSONALIZATIONS_CACHE_KEY,
+            PROFILE_CACHE_KEY: ()=>PROFILE_CACHE_KEY
         });
-        var _contentful_optimization_api_client__rspack_import_0 = __webpack_require__("@contentful/optimization-api-client");
-        var logger__rspack_import_1 = __webpack_require__("../../lib/logger/dist/index.mjs");
-        var _global_constants__rspack_import_3 = __webpack_require__("./src/global-constants.ts");
-        var _lib_interceptor__rspack_import_2 = __webpack_require__("./src/lib/interceptor/InterceptorManager.ts");
-        class CoreBase {
-            api;
-            eventBuilder;
-            config;
-            interceptors = {
-                event: new _lib_interceptor__rspack_import_2.v(),
-                state: new _lib_interceptor__rspack_import_2.v()
-            };
-            constructor(config){
-                this.config = config;
-                const { analytics, personalization, eventBuilder, logLevel, environment, clientId } = config;
-                logger__rspack_import_1.vF.addSink(new logger__rspack_import_1.vg(logLevel));
-                const apiConfig = {
-                    ...analytics,
-                    ...personalization,
-                    clientId,
-                    environment
+        const OPTIMIZATION_CORE_SDK_VERSION = "0.1.0-alpha10";
+        const OPTIMIZATION_CORE_SDK_NAME = "@contentful/optimization-core";
+        const ANONYMOUS_ID_COOKIE = 'ctfl-opt-aid';
+        const ANONYMOUS_ID_KEY = '__ctfl_opt_anonymous_id__';
+        const CONSENT_KEY = '__ctfl_opt_consent__';
+        const CHANGES_CACHE_KEY = '__ctfl_opt_changes__';
+        const DEBUG_FLAG_KEY = '__ctfl_opt_debug__';
+        const PROFILE_CACHE_KEY = '__ctfl_opt_profile__';
+        const PERSONALIZATIONS_CACHE_KEY = '__ctfl_opt_personalizations__';
+        const ANONYMOUS_ID_COOKIE_LEGACY = 'ntaid';
+        const ANONYMOUS_ID_KEY_LEGACY = '__nt_anonymous_id__';
+    },
+    "./src/symbols.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            PREVIEW_PANEL_SIGNALS_SYMBOL: ()=>PREVIEW_PANEL_SIGNALS_SYMBOL,
+            PREVIEW_PANEL_SIGNAL_FNS_SYMBOL: ()=>PREVIEW_PANEL_SIGNAL_FNS_SYMBOL
+        });
+        const PREVIEW_PANEL_SIGNALS_SYMBOL = Symbol.for('ctfl.optimization.preview.signals');
+        const PREVIEW_PANEL_SIGNAL_FNS_SYMBOL = Symbol.for('ctfl.optimization.preview.signalFns');
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        OPTIMIZATION_CORE_SDK_NAME: ()=>constants.OPTIMIZATION_CORE_SDK_NAME,
+        ANONYMOUS_ID_KEY: ()=>constants.ANONYMOUS_ID_KEY,
+        OPTIMIZATION_CORE_SDK_VERSION: ()=>constants.OPTIMIZATION_CORE_SDK_VERSION,
+        PROFILE_CACHE_KEY: ()=>constants.PROFILE_CACHE_KEY,
+        PersonalizationStateful: ()=>personalization_PersonalizationStateful,
+        batch: ()=>signals_core_namespaceObject.batch,
+        AnalyticsStateless: ()=>analytics_AnalyticsStateless,
+        PersonalizationStateless: ()=>personalization_PersonalizationStateless,
+        InterceptorManager: ()=>InterceptorManager,
+        AnalyticsStateful: ()=>analytics_AnalyticsStateful,
+        CONSENT_KEY: ()=>constants.CONSENT_KEY,
+        signals: ()=>signals,
+        ANONYMOUS_ID_KEY_LEGACY: ()=>constants.ANONYMOUS_ID_KEY_LEGACY,
+        CoreStateless: ()=>src_CoreStateless,
+        PREVIEW_PANEL_SIGNAL_FNS_SYMBOL: ()=>symbols.PREVIEW_PANEL_SIGNAL_FNS_SYMBOL,
+        CoreStateful: ()=>src_CoreStateful,
+        MergeTagValueResolver: ()=>resolvers_MergeTagValueResolver,
+        signalFns: ()=>signalFns,
+        DEBUG_FLAG_KEY: ()=>constants.DEBUG_FLAG_KEY,
+        FlagsResolver: ()=>resolvers_FlagsResolver,
+        ANONYMOUS_ID_COOKIE_LEGACY: ()=>constants.ANONYMOUS_ID_COOKIE_LEGACY,
+        ANONYMOUS_ID_COOKIE: ()=>constants.ANONYMOUS_ID_COOKIE,
+        PERSONALIZATIONS_CACHE_KEY: ()=>constants.PERSONALIZATIONS_CACHE_KEY,
+        effect: ()=>signals_core_namespaceObject.effect,
+        PersonalizedEntryResolver: ()=>resolvers_PersonalizedEntryResolver,
+        PREVIEW_PANEL_SIGNALS_SYMBOL: ()=>symbols.PREVIEW_PANEL_SIGNALS_SYMBOL,
+        guardedBy: ()=>guardedBy,
+        CHANGES_CACHE_KEY: ()=>constants.CHANGES_CACHE_KEY,
+        PersonalizationBase: ()=>personalization_PersonalizationBase
+    });
+    const signals_core_namespaceObject = require("@preact/signals-core");
+    const FlagsResolver = {
+        resolve (changes) {
+            if (!changes) return {};
+            return changes.reduce((acc, { key, value })=>{
+                const actualValue = 'object' == typeof value && null !== value && 'value' in value && 'object' == typeof value.value ? value.value : value;
+                acc[key] = actualValue;
+                return acc;
+            }, {});
+        }
+    };
+    const resolvers_FlagsResolver = FlagsResolver;
+    const api_schemas_namespaceObject = require("@contentful/optimization-api-client/api-schemas");
+    const logger_namespaceObject = require("@contentful/optimization-api-client/logger");
+    const logger = (0, logger_namespaceObject.createScopedLogger)('Personalization');
+    const RESOLUTION_WARNING_BASE = 'Could not resolve Merge Tag value:';
+    const getAtPath = (value, path)=>{
+        if (!value || 'object' != typeof value) return;
+        if (!path) return value;
+        let current = value;
+        const segments = path.split('.').filter(Boolean);
+        for (const segment of segments){
+            if (!current || 'object' != typeof current && 'function' != typeof current) return;
+            current = Reflect.get(current, segment);
+        }
+        return current;
+    };
+    const MergeTagValueResolver = {
+        normalizeSelectors (id) {
+            return id.split('_').map((_path, index, paths)=>{
+                const dotPath = paths.slice(0, index).join('.');
+                const underScorePath = paths.slice(index).join('_');
+                return [
+                    dotPath,
+                    underScorePath
+                ].filter((path)=>'' !== path).join('.');
+            });
+        },
+        getValueFromProfile (id, profile) {
+            const selectors = MergeTagValueResolver.normalizeSelectors(id);
+            const matchingSelector = selectors.find((selector)=>getAtPath(profile, selector));
+            if (!matchingSelector) return;
+            const value = getAtPath(profile, matchingSelector);
+            if (!value || 'string' != typeof value && 'number' != typeof value && 'boolean' != typeof value) return;
+            return `${value}`;
+        },
+        resolve (mergeTagEntry, profile) {
+            if (!(0, api_schemas_namespaceObject.isMergeTagEntry)(mergeTagEntry)) return void logger.warn(`${RESOLUTION_WARNING_BASE} supplied entry is not a Merge Tag entry`);
+            const { fields: { nt_fallback: fallback } } = mergeTagEntry;
+            if (!api_schemas_namespaceObject.Profile.safeParse(profile).success) {
+                logger.warn(`${RESOLUTION_WARNING_BASE} no valid profile`);
+                return fallback;
+            }
+            return MergeTagValueResolver.getValueFromProfile(mergeTagEntry.fields.nt_mergetag_id, profile) ?? fallback;
+        }
+    };
+    const resolvers_MergeTagValueResolver = MergeTagValueResolver;
+    const PersonalizedEntryResolver_logger = (0, logger_namespaceObject.createScopedLogger)('Personalization');
+    const PersonalizedEntryResolver_RESOLUTION_WARNING_BASE = 'Could not resolve personalized entry variant:';
+    const PersonalizedEntryResolver = {
+        getPersonalizationEntry ({ personalizedEntry, selectedPersonalizations }, skipValidation = false) {
+            if (!skipValidation && (!selectedPersonalizations.length || !(0, api_schemas_namespaceObject.isPersonalizedEntry)(personalizedEntry))) return;
+            const personalizationEntry = personalizedEntry.fields.nt_experiences.filter((maybePersonalization)=>(0, api_schemas_namespaceObject.isPersonalizationEntry)(maybePersonalization)).find((personalizationEntry)=>selectedPersonalizations.some(({ experienceId })=>experienceId === personalizationEntry.fields.nt_experience_id));
+            return personalizationEntry;
+        },
+        getSelectedPersonalization ({ personalizationEntry, selectedPersonalizations }, skipValidation = false) {
+            if (!skipValidation && (!selectedPersonalizations.length || !(0, api_schemas_namespaceObject.isPersonalizationEntry)(personalizationEntry))) return;
+            const selectedPersonalization = selectedPersonalizations.find(({ experienceId })=>experienceId === personalizationEntry.fields.nt_experience_id);
+            return selectedPersonalization;
+        },
+        getSelectedVariant ({ personalizedEntry, personalizationEntry, selectedVariantIndex }, skipValidation = false) {
+            if (!skipValidation && (!(0, api_schemas_namespaceObject.isPersonalizedEntry)(personalizedEntry) || !(0, api_schemas_namespaceObject.isPersonalizationEntry)(personalizationEntry))) return;
+            const relevantVariants = personalizationEntry.fields.nt_config?.components?.filter((component)=>(0, api_schemas_namespaceObject.isEntryReplacementComponent)(component) && !component.baseline.hidden).find((component)=>component.baseline.id === personalizedEntry.sys.id)?.variants;
+            if (!relevantVariants?.length) return;
+            return relevantVariants.at(selectedVariantIndex - 1);
+        },
+        getSelectedVariantEntry ({ personalizationEntry, selectedVariant }, skipValidation = false) {
+            if (!skipValidation && (!(0, api_schemas_namespaceObject.isPersonalizationEntry)(personalizationEntry) || !(0, api_schemas_namespaceObject.isEntryReplacementVariant)(selectedVariant))) return;
+            const selectedVariantEntry = personalizationEntry.fields.nt_variants?.find((variant)=>variant.sys.id === selectedVariant.id);
+            return (0, api_schemas_namespaceObject.isEntry)(selectedVariantEntry) ? selectedVariantEntry : void 0;
+        },
+        resolve (entry, selectedPersonalizations) {
+            PersonalizedEntryResolver_logger.debug(`Resolving personalized entry for baseline entry ${entry.sys.id}`);
+            if (!selectedPersonalizations?.length) {
+                PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} no selectedPersonalizations exist for the current profile`);
+                return {
+                    entry
                 };
-                this.api = new _contentful_optimization_api_client__rspack_import_0.ApiClient(apiConfig);
-                this.eventBuilder = new _contentful_optimization_api_client__rspack_import_0.EventBuilder(eventBuilder ?? {
-                    channel: 'server',
-                    library: {
-                        name: 'Optimization Core',
-                        version: _global_constants__rspack_import_3.E
-                    }
-                });
-            }
-            getCustomFlag(name, changes) {
-                return this.personalization.getCustomFlag(name, changes);
-            }
-            personalizeEntry(entry, personalizations) {
-                return this.personalization.personalizeEntry(entry, personalizations);
-            }
-            getMergeTagValue(embeddedEntryNodeTarget, profile) {
-                return this.personalization.getMergeTagValue(embeddedEntryNodeTarget, profile);
             }
-            async identify(payload) {
-                return await this.personalization.identify(payload);
-            }
-            async page(payload) {
-                return await this.personalization.page(payload);
+            if (!(0, api_schemas_namespaceObject.isPersonalizedEntry)(entry)) {
+                PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} entry ${entry.sys.id} is not personalized`);
+                return {
+                    entry
+                };
             }
-            async screen(payload) {
-                return await this.personalization.screen(payload);
+            const personalizationEntry = PersonalizedEntryResolver.getPersonalizationEntry({
+                personalizedEntry: entry,
+                selectedPersonalizations
+            }, true);
+            if (!personalizationEntry) {
+                PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a personalization entry for ${entry.sys.id}`);
+                return {
+                    entry
+                };
             }
-            async track(payload) {
-                return await this.personalization.track(payload);
+            const selectedPersonalization = PersonalizedEntryResolver.getSelectedPersonalization({
+                personalizationEntry,
+                selectedPersonalizations
+            }, true);
+            const selectedVariantIndex = selectedPersonalization?.variantIndex ?? 0;
+            if (0 === selectedVariantIndex) {
+                PersonalizedEntryResolver_logger.debug(`Resolved personalization entry for entry ${entry.sys.id} is baseline`);
+                return {
+                    entry
+                };
             }
-            async trackComponentView(payload, duplicationScope) {
-                if (payload.sticky) return await this.personalization.trackComponentView(payload, duplicationScope);
-                await this.analytics.trackComponentView(payload, duplicationScope);
+            const selectedVariant = PersonalizedEntryResolver.getSelectedVariant({
+                personalizedEntry: entry,
+                personalizationEntry,
+                selectedVariantIndex
+            }, true);
+            if (!selectedVariant) {
+                PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a valid replacement variant entry for ${entry.sys.id}`);
+                return {
+                    entry
+                };
             }
-            async trackFlagView(payload, duplicationScope) {
-                await this.analytics.trackFlagView(payload, duplicationScope);
+            const selectedVariantEntry = PersonalizedEntryResolver.getSelectedVariantEntry({
+                personalizationEntry,
+                selectedVariant
+            }, true);
+            if (selectedVariantEntry) PersonalizedEntryResolver_logger.debug(`Entry ${entry.sys.id} has been resolved to variant entry ${selectedVariantEntry.sys.id}`);
+            else {
+                PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a valid replacement variant entry for ${entry.sys.id}`);
+                return {
+                    entry
+                };
             }
+            return {
+                entry: selectedVariantEntry,
+                personalization: selectedPersonalization
+            };
         }
-        const __rspack_default_export = CoreBase;
-    },
-    "./src/CoreStateful.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            A: ()=>__rspack_default_export
-        });
-        var _analytics__rspack_import_0 = __webpack_require__("./src/analytics/index.ts");
-        var _CoreBase__rspack_import_1 = __webpack_require__("./src/CoreBase.ts");
-        var _personalization__rspack_import_2 = __webpack_require__("./src/personalization/index.ts");
-        var _signals__rspack_import_3 = __webpack_require__("./src/signals.ts");
-        class CoreStateful extends _CoreBase__rspack_import_1.A {
-            analytics;
-            personalization;
-            constructor(config){
-                super(config);
-                const { allowedEventTypes, defaults, getAnonymousId, preventedComponentEvents } = config;
-                if (defaults?.consent !== void 0) {
-                    const { consent: defaultConsent } = defaults;
-                    _signals__rspack_import_3.vJ.value = defaultConsent;
-                }
-                this.analytics = new _analytics__rspack_import_0.R({
-                    api: this.api,
-                    builder: this.eventBuilder,
-                    config: {
-                        allowedEventTypes,
-                        preventedComponentEvents,
-                        defaults: {
-                            consent: defaults?.consent,
-                            profile: defaults?.profile
-                        }
-                    },
-                    interceptors: this.interceptors
-                });
-                this.personalization = new _personalization__rspack_import_2.$C({
-                    api: this.api,
-                    builder: this.eventBuilder,
-                    config: {
-                        allowedEventTypes,
-                        getAnonymousId,
-                        preventedComponentEvents,
-                        defaults: {
-                            consent: defaults?.consent,
-                            changes: defaults?.changes,
-                            profile: defaults?.profile,
-                            personalizations: defaults?.personalizations
-                        }
-                    },
-                    interceptors: this.interceptors
+    };
+    const resolvers_PersonalizedEntryResolver = PersonalizedEntryResolver;
+    const signals_changes = (0, signals_core_namespaceObject.signal)();
+    const blockedEvent = (0, signals_core_namespaceObject.signal)();
+    const consent = (0, signals_core_namespaceObject.signal)();
+    const signals_event = (0, signals_core_namespaceObject.signal)();
+    const flags = (0, signals_core_namespaceObject.computed)(()=>resolvers_FlagsResolver.resolve(signals_changes.value ?? []));
+    const online = (0, signals_core_namespaceObject.signal)(true);
+    const previewPanelAttached = (0, signals_core_namespaceObject.signal)(false);
+    const previewPanelOpen = (0, signals_core_namespaceObject.signal)(false);
+    const signals_personalizations = (0, signals_core_namespaceObject.signal)();
+    const signals_profile = (0, signals_core_namespaceObject.signal)();
+    function toObservable(s) {
+        return {
+            subscribe (next) {
+                const dispose = (0, signals_core_namespaceObject.effect)(()=>{
+                    next(s.value);
                 });
-            }
-            get states() {
                 return {
-                    consent: (0, _signals__rspack_import_3.br)(_signals__rspack_import_3.vJ),
-                    eventStream: (0, _signals__rspack_import_3.br)(_signals__rspack_import_3.f0),
-                    flags: (0, _signals__rspack_import_3.br)(_signals__rspack_import_3.Mv),
-                    personalizations: (0, _signals__rspack_import_3.br)(_signals__rspack_import_3.wh),
-                    profile: (0, _signals__rspack_import_3.br)(_signals__rspack_import_3.ME)
+                    unsubscribe: dispose
                 };
             }
-            reset() {
-                (0, _signals__rspack_import_3.vA)(()=>{
-                    _signals__rspack_import_3.f0.value = void 0;
-                    _signals__rspack_import_3.Ao.value = void 0;
-                    _signals__rspack_import_3.ME.value = void 0;
-                    _signals__rspack_import_3.wh.value = void 0;
+        };
+    }
+    const signals = {
+        blockedEvent,
+        changes: signals_changes,
+        consent,
+        event: signals_event,
+        flags,
+        online,
+        previewPanelAttached,
+        previewPanelOpen,
+        personalizations: signals_personalizations,
+        profile: signals_profile
+    };
+    const signalFns = {
+        batch: signals_core_namespaceObject.batch,
+        computed: signals_core_namespaceObject.computed,
+        effect: signals_core_namespaceObject.effect,
+        untracked: signals_core_namespaceObject.untracked
+    };
+    const isFunction = (v)=>'function' == typeof v;
+    const nameToString = (name)=>'string' == typeof name ? name : 'symbol' == typeof name ? name.description ?? String(name) : String(name);
+    const isOnBlockedKey = (v)=>'string' == typeof v || 'symbol' == typeof v;
+    const isAsyncFunction = (fn)=>'[object AsyncFunction]' === Object.prototype.toString.call(fn);
+    function guardedBy(predicateName, opts) {
+        return function(_value, context) {
+            const decoratedName = nameToString(context.name);
+            context.addInitializer(function() {
+                const originalUnknown = Reflect.get(this, context.name);
+                if (!isFunction(originalUnknown)) return;
+                const original = originalUnknown;
+                const originalIsAsync = isAsyncFunction(original);
+                const resolvePredicate = (self)=>{
+                    const { [predicateName]: cand } = self;
+                    if (!isFunction(cand)) throw new TypeError(`@guardedBy expects predicate "${String(predicateName)}" to be a synchronous function.`);
+                    return cand;
+                };
+                const computeAllowed = (self, args)=>{
+                    const pred = resolvePredicate(self);
+                    const ok = Boolean(pred.call(self, decoratedName, args));
+                    return opts?.invert === true ? !ok : ok;
+                };
+                const runOnBlocked = (self, args)=>{
+                    const { onBlocked } = opts ?? {};
+                    if (void 0 === onBlocked) return;
+                    if (isFunction(onBlocked)) return void onBlocked.call(self, decoratedName, args);
+                    if (isOnBlockedKey(onBlocked)) {
+                        const { [onBlocked]: handlerCandidate } = self;
+                        if (isFunction(handlerCandidate)) handlerCandidate.call(self, decoratedName, args);
+                    }
+                };
+                const blockedReturn = ()=>originalIsAsync ? Promise.resolve(void 0) : void 0;
+                const wrapped = function(...args) {
+                    if (!computeAllowed(this, args)) {
+                        runOnBlocked(this, args);
+                        return blockedReturn();
+                    }
+                    return original.call(this, ...args);
+                };
+                Reflect.set(this, context.name, wrapped);
+            });
+        };
+    }
+    const toPositiveInt = (value, fallback)=>{
+        if (!Number.isFinite(value) || void 0 === value || value < 1) return fallback;
+        return Math.floor(value);
+    };
+    const toRatio = (value, fallback)=>{
+        if (!Number.isFinite(value) || void 0 === value) return fallback;
+        return Math.min(1, Math.max(0, value));
+    };
+    const DEFAULT_QUEUE_FLUSH_POLICY = {
+        baseBackoffMs: 500,
+        maxBackoffMs: 30000,
+        jitterRatio: 0.2,
+        maxConsecutiveFailures: 8,
+        circuitOpenMs: 120000
+    };
+    const resolveQueueFlushPolicy = (policy, defaults = DEFAULT_QUEUE_FLUSH_POLICY)=>{
+        const baseBackoffMs = toPositiveInt(policy?.baseBackoffMs, defaults.baseBackoffMs);
+        const maxBackoffMs = Math.max(baseBackoffMs, toPositiveInt(policy?.maxBackoffMs, defaults.maxBackoffMs));
+        return {
+            baseBackoffMs,
+            maxBackoffMs,
+            jitterRatio: toRatio(policy?.jitterRatio, defaults.jitterRatio),
+            maxConsecutiveFailures: toPositiveInt(policy?.maxConsecutiveFailures, defaults.maxConsecutiveFailures),
+            circuitOpenMs: toPositiveInt(policy?.circuitOpenMs, defaults.circuitOpenMs),
+            onCircuitOpen: policy?.onCircuitOpen,
+            onFlushFailure: policy?.onFlushFailure,
+            onFlushRecovered: policy?.onFlushRecovered
+        };
+    };
+    const computeQueueFlushRetryDelayMs = (options)=>{
+        const { consecutiveFailures, policy: { baseBackoffMs, jitterRatio, maxBackoffMs } } = options;
+        const exponential = baseBackoffMs * 2 ** Math.max(0, consecutiveFailures - 1);
+        const capped = Math.min(maxBackoffMs, exponential);
+        const jitter = capped * jitterRatio * Math.random();
+        return Math.round(capped + jitter);
+    };
+    const createQueueFlushFailureWindow = (options)=>{
+        const { consecutiveFailures, failureTimestamp, retryDelayMs, policy: { maxConsecutiveFailures, circuitOpenMs } } = options;
+        if (consecutiveFailures < maxConsecutiveFailures) return {
+            openedCircuit: false,
+            retryDelayMs,
+            nextFlushAllowedAt: failureTimestamp + retryDelayMs,
+            circuitOpenUntil: 0
+        };
+        const circuitOpenUntil = failureTimestamp + circuitOpenMs;
+        return {
+            openedCircuit: true,
+            retryDelayMs: circuitOpenMs,
+            nextFlushAllowedAt: circuitOpenUntil,
+            circuitOpenUntil
+        };
+    };
+    class QueueFlushRuntime {
+        circuitOpenUntil = 0;
+        flushFailureCount = 0;
+        flushInFlight = false;
+        nextFlushAllowedAt = 0;
+        onCallbackError;
+        onRetry;
+        policy;
+        retryTimer;
+        constructor(options){
+            const { onCallbackError, onRetry, policy } = options;
+            this.policy = policy;
+            this.onRetry = onRetry;
+            this.onCallbackError = onCallbackError;
+        }
+        reset() {
+            this.clearScheduledRetry();
+            this.circuitOpenUntil = 0;
+            this.flushFailureCount = 0;
+            this.flushInFlight = false;
+            this.nextFlushAllowedAt = 0;
+        }
+        clearScheduledRetry() {
+            if (void 0 === this.retryTimer) return;
+            clearTimeout(this.retryTimer);
+            this.retryTimer = void 0;
+        }
+        shouldSkip(options) {
+            const { force, isOnline } = options;
+            if (this.flushInFlight) return true;
+            if (force) return false;
+            if (!isOnline) return true;
+            const now = Date.now();
+            if (this.nextFlushAllowedAt > now) return true;
+            if (this.circuitOpenUntil > now) return true;
+            return false;
+        }
+        markFlushStarted() {
+            this.flushInFlight = true;
+        }
+        markFlushFinished() {
+            this.flushInFlight = false;
+        }
+        handleFlushSuccess() {
+            const { flushFailureCount: previousConsecutiveFailures } = this;
+            this.clearScheduledRetry();
+            this.circuitOpenUntil = 0;
+            this.flushFailureCount = 0;
+            this.nextFlushAllowedAt = 0;
+            if (previousConsecutiveFailures <= 0) return;
+            this.safeInvoke('onFlushRecovered', {
+                consecutiveFailures: previousConsecutiveFailures
+            });
+        }
+        handleFlushFailure(options) {
+            const { queuedBatches, queuedEvents } = options;
+            this.flushFailureCount += 1;
+            const retryDelayMs = computeQueueFlushRetryDelayMs({
+                consecutiveFailures: this.flushFailureCount,
+                policy: this.policy
+            });
+            const failureTimestamp = Date.now();
+            const failureContext = {
+                consecutiveFailures: this.flushFailureCount,
+                queuedBatches,
+                queuedEvents,
+                retryDelayMs
+            };
+            this.safeInvoke('onFlushFailure', failureContext);
+            const failureWindow = createQueueFlushFailureWindow({
+                consecutiveFailures: this.flushFailureCount,
+                failureTimestamp,
+                retryDelayMs,
+                policy: this.policy
+            });
+            const { circuitOpenUntil, nextFlushAllowedAt, openedCircuit, retryDelayMs: scheduledRetryDelayMs } = failureWindow;
+            this.nextFlushAllowedAt = nextFlushAllowedAt;
+            if (openedCircuit) {
+                this.circuitOpenUntil = circuitOpenUntil;
+                this.safeInvoke('onCircuitOpen', {
+                    ...failureContext,
+                    retryDelayMs: scheduledRetryDelayMs
                 });
             }
-            async flush() {
-                await this.analytics.flush();
-                await this.personalization.flush();
-            }
-            consent(accept) {
-                _signals__rspack_import_3.vJ.value = accept;
-            }
-            online(isOnline) {
-                _signals__rspack_import_3.WD.value = isOnline;
-            }
-            registerPreviewPanel(previewPanel) {
-                previewPanel.signals = _signals__rspack_import_3.QO;
-            }
+            this.scheduleRetry(scheduledRetryDelayMs);
         }
-        const __rspack_default_export = CoreStateful;
-    },
-    "./src/CoreStateless.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            A: ()=>__rspack_default_export
-        });
-        var _analytics__rspack_import_0 = __webpack_require__("./src/analytics/index.ts");
-        var _CoreBase__rspack_import_1 = __webpack_require__("./src/CoreBase.ts");
-        var _personalization__rspack_import_2 = __webpack_require__("./src/personalization/index.ts");
-        class CoreStateless extends _CoreBase__rspack_import_1.A {
-            analytics;
-            personalization;
-            constructor(config){
-                super(config);
-                this.analytics = new _analytics__rspack_import_0.v({
-                    api: this.api,
-                    builder: this.eventBuilder,
-                    interceptors: this.interceptors
-                });
-                this.personalization = new _personalization__rspack_import_2.jL({
-                    api: this.api,
-                    builder: this.eventBuilder,
-                    interceptors: this.interceptors
-                });
+        scheduleRetry(delayMs) {
+            this.clearScheduledRetry();
+            this.retryTimer = setTimeout(()=>{
+                this.retryTimer = void 0;
+                this.onRetry();
+            }, delayMs);
+        }
+        safeInvoke(...args) {
+            const [callbackName, payload] = args;
+            try {
+                if ('onFlushRecovered' === callbackName) return void this.policy.onFlushRecovered?.(payload);
+                if ('onCircuitOpen' === callbackName) return void this.policy.onCircuitOpen?.(payload);
+                this.policy.onFlushFailure?.(payload);
+            } catch (error) {
+                this.onCallbackError?.(callbackName, error);
             }
         }
-        const __rspack_default_export = CoreStateless;
-    },
-    "./src/ProductBase.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            A: ()=>__rspack_default_export
-        });
-        var _lib_value_presence_ValuePresence__rspack_import_0 = __webpack_require__("./src/lib/value-presence/ValuePresence.ts");
-        const defaultAllowedEvents = [
-            'page',
-            'identify'
-        ];
-        class ProductBase {
-            allowedEventTypes;
-            builder;
-            api;
-            duplicationDetector;
-            interceptors;
-            constructor(options){
-                const { api, builder, config, interceptors } = options;
-                this.allowedEventTypes = config?.allowedEventTypes ?? defaultAllowedEvents;
-                this.api = api;
-                this.builder = builder;
-                this.duplicationDetector = new _lib_value_presence_ValuePresence__rspack_import_0.A(config?.preventedComponentEvents);
-                this.interceptors = interceptors;
+    }
+    const ProductBase_logger = (0, logger_namespaceObject.createScopedLogger)('ProductBase');
+    const defaultAllowedEvents = [
+        'identify',
+        'page',
+        'screen'
+    ];
+    class ProductBase {
+        allowedEventTypes;
+        builder;
+        api;
+        interceptors;
+        onEventBlocked;
+        constructor(options){
+            const { api, builder, config, interceptors } = options;
+            this.allowedEventTypes = config?.allowedEventTypes ?? defaultAllowedEvents;
+            this.api = api;
+            this.builder = builder;
+            this.interceptors = interceptors;
+            this.onEventBlocked = config?.onEventBlocked;
+        }
+        reportBlockedEvent(reason, product, method, args) {
+            const event = {
+                reason,
+                product,
+                method,
+                args
+            };
+            try {
+                this.onEventBlocked?.(event);
+            } catch (error) {
+                ProductBase_logger.warn(`onEventBlocked callback failed for method "${method}"`, error);
             }
+            blockedEvent.value = event;
         }
-        const __rspack_default_export = ProductBase;
-    },
-    "./src/analytics/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            R: ()=>analytics_AnalyticsStateful,
-            v: ()=>analytics_AnalyticsStateless
-        });
-        var optimization_api_client_ = __webpack_require__("@contentful/optimization-api-client");
-        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
-        var guardedBy = __webpack_require__("./src/lib/decorators/guardedBy.ts");
-        var signals = __webpack_require__("./src/signals.ts");
-        var ProductBase = __webpack_require__("./src/ProductBase.ts");
-        class AnalyticsBase extends ProductBase.A {
-        }
-        const analytics_AnalyticsBase = AnalyticsBase;
-        function applyDecs2203RFactory() {
-            function createAddInitializerMethod(initializers, decoratorFinishedRef) {
-                return function(initializer) {
-                    assertNotFinished(decoratorFinishedRef, "addInitializer");
-                    assertCallable(initializer, "An initializer");
-                    initializers.push(initializer);
+    }
+    const src_ProductBase = ProductBase;
+    class AnalyticsBase extends src_ProductBase {
+    }
+    const analytics_AnalyticsBase = AnalyticsBase;
+    function applyDecs2203RFactory() {
+        function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+            return function(initializer) {
+                assertNotFinished(decoratorFinishedRef, "addInitializer");
+                assertCallable(initializer, "An initializer");
+                initializers.push(initializer);
+            };
+        }
+        function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+            var kindStr;
+            switch(kind){
+                case 1:
+                    kindStr = "accessor";
+                    break;
+                case 2:
+                    kindStr = "method";
+                    break;
+                case 3:
+                    kindStr = "getter";
+                    break;
+                case 4:
+                    kindStr = "setter";
+                    break;
+                default:
+                    kindStr = "field";
+            }
+            var ctx = {
+                kind: kindStr,
+                name: isPrivate ? "#" + name : name,
+                static: isStatic,
+                private: isPrivate,
+                metadata: metadata
+            };
+            var decoratorFinishedRef = {
+                v: false
+            };
+            ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+            var get, set;
+            if (0 === kind) if (isPrivate) {
+                get = desc.get;
+                set = desc.set;
+            } else {
+                get = function() {
+                    return this[name];
+                };
+                set = function(v) {
+                    this[name] = v;
                 };
             }
-            function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
-                var kindStr;
-                switch(kind){
-                    case 1:
-                        kindStr = "accessor";
-                        break;
-                    case 2:
-                        kindStr = "method";
-                        break;
-                    case 3:
-                        kindStr = "getter";
-                        break;
-                    case 4:
-                        kindStr = "setter";
-                        break;
-                    default:
-                        kindStr = "field";
-                }
-                var ctx = {
-                    kind: kindStr,
-                    name: isPrivate ? "#" + name : name,
-                    static: isStatic,
-                    private: isPrivate,
-                    metadata: metadata
+            else if (2 === kind) get = function() {
+                return desc.value;
+            };
+            else {
+                if (1 === kind || 3 === kind) get = function() {
+                    return desc.get.call(this);
                 };
-                var decoratorFinishedRef = {
-                    v: false
+                if (1 === kind || 4 === kind) set = function(v) {
+                    desc.set.call(this, v);
                 };
-                ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
-                var get, set;
-                if (0 === kind) if (isPrivate) {
-                    get = desc.get;
-                    set = desc.set;
-                } else {
-                    get = function() {
-                        return this[name];
-                    };
-                    set = function(v) {
-                        this[name] = v;
-                    };
+            }
+            ctx.access = get && set ? {
+                get: get,
+                set: set
+            } : get ? {
+                get: get
+            } : {
+                set: set
+            };
+            try {
+                return dec(value, ctx);
+            } finally{
+                decoratorFinishedRef.v = true;
+            }
+        }
+        function assertNotFinished(decoratorFinishedRef, fnName) {
+            if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+        }
+        function assertCallable(fn, hint) {
+            if ("function" != typeof fn) throw new TypeError(hint + " must be a function");
+        }
+        function assertValidReturnValue(kind, value) {
+            var type = typeof value;
+            if (1 === kind) {
+                if ("object" !== type || null === value) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+                if (void 0 !== value.get) assertCallable(value.get, "accessor.get");
+                if (void 0 !== value.set) assertCallable(value.set, "accessor.set");
+                if (void 0 !== value.init) assertCallable(value.init, "accessor.init");
+            } else if ("function" !== type) {
+                var hint;
+                hint = 0 === kind ? "field" : 10 === kind ? "class" : "method";
+                throw new TypeError(hint + " decorators must return a function or void 0");
+            }
+        }
+        function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+            var decs = decInfo[0];
+            var desc, init, value;
+            if (isPrivate) desc = 0 === kind || 1 === kind ? {
+                get: decInfo[3],
+                set: decInfo[4]
+            } : 3 === kind ? {
+                get: decInfo[3]
+            } : 4 === kind ? {
+                set: decInfo[3]
+            } : {
+                value: decInfo[3]
+            };
+            else if (0 !== kind) desc = Object.getOwnPropertyDescriptor(base, name);
+            if (1 === kind) value = {
+                get: desc.get,
+                set: desc.set
+            };
+            else if (2 === kind) value = desc.value;
+            else if (3 === kind) value = desc.get;
+            else if (4 === kind) value = desc.set;
+            var newValue, get, set;
+            if ("function" == typeof decs) {
+                newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                if (void 0 !== newValue) {
+                    assertValidReturnValue(kind, newValue);
+                    if (0 === kind) init = newValue;
+                    else if (1 === kind) {
+                        init = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+                        value = {
+                            get: get,
+                            set: set
+                        };
+                    } else value = newValue;
+                }
+            } else for(var i = decs.length - 1; i >= 0; i--){
+                var dec = decs[i];
+                newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                if (void 0 !== newValue) {
+                    assertValidReturnValue(kind, newValue);
+                    var newInit;
+                    if (0 === kind) newInit = newValue;
+                    else if (1 === kind) {
+                        newInit = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+                        value = {
+                            get: get,
+                            set: set
+                        };
+                    } else value = newValue;
+                    if (void 0 !== newInit) if (void 0 === init) init = newInit;
+                    else if ("function" == typeof init) init = [
+                        init,
+                        newInit
+                    ];
+                    else init.push(newInit);
                 }
-                else if (2 === kind) get = function() {
-                    return desc.value;
+            }
+            if (0 === kind || 1 === kind) {
+                if (void 0 === init) init = function(instance, init) {
+                    return init;
                 };
-                else {
-                    if (1 === kind || 3 === kind) get = function() {
-                        return desc.get.call(this);
+                else if ("function" != typeof init) {
+                    var ownInitializers = init;
+                    init = function(instance, init) {
+                        var value = init;
+                        for(var i = 0; i < ownInitializers.length; i++)value = ownInitializers[i].call(instance, value);
+                        return value;
                     };
-                    if (1 === kind || 4 === kind) set = function(v) {
-                        desc.set.call(this, v);
+                } else {
+                    var originalInitializer = init;
+                    init = function(instance, init) {
+                        return originalInitializer.call(instance, init);
                     };
                 }
-                ctx.access = get && set ? {
-                    get: get,
-                    set: set
-                } : get ? {
-                    get: get
-                } : {
-                    set: set
-                };
-                try {
-                    return dec(value, ctx);
-                } finally{
-                    decoratorFinishedRef.v = true;
-                }
-            }
-            function assertNotFinished(decoratorFinishedRef, fnName) {
-                if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+                ret.push(init);
             }
-            function assertCallable(fn, hint) {
-                if ("function" != typeof fn) throw new TypeError(hint + " must be a function");
-            }
-            function assertValidReturnValue(kind, value) {
-                var type = typeof value;
+            if (0 !== kind) {
                 if (1 === kind) {
-                    if ("object" !== type || null === value) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
-                    if (void 0 !== value.get) assertCallable(value.get, "accessor.get");
-                    if (void 0 !== value.set) assertCallable(value.set, "accessor.set");
-                    if (void 0 !== value.init) assertCallable(value.init, "accessor.init");
-                } else if ("function" !== type) {
-                    var hint;
-                    hint = 0 === kind ? "field" : 10 === kind ? "class" : "method";
-                    throw new TypeError(hint + " decorators must return a function or void 0");
-                }
+                    desc.get = value.get;
+                    desc.set = value.set;
+                } else if (2 === kind) desc.value = value;
+                else if (3 === kind) desc.get = value;
+                else if (4 === kind) desc.set = value;
+                if (isPrivate) if (1 === kind) {
+                    ret.push(function(instance, args) {
+                        return value.get.call(instance, args);
+                    });
+                    ret.push(function(instance, args) {
+                        return value.set.call(instance, args);
+                    });
+                } else if (2 === kind) ret.push(value);
+                else ret.push(function(instance, args) {
+                    return value.call(instance, args);
+                });
+                else Object.defineProperty(base, name, desc);
             }
-            function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
-                var decs = decInfo[0];
-                var desc, init, value;
-                if (isPrivate) desc = 0 === kind || 1 === kind ? {
-                    get: decInfo[3],
-                    set: decInfo[4]
-                } : 3 === kind ? {
-                    get: decInfo[3]
-                } : 4 === kind ? {
-                    set: decInfo[3]
-                } : {
-                    value: decInfo[3]
-                };
-                else if (0 !== kind) desc = Object.getOwnPropertyDescriptor(base, name);
-                if (1 === kind) value = {
-                    get: desc.get,
-                    set: desc.set
-                };
-                else if (2 === kind) value = desc.value;
-                else if (3 === kind) value = desc.get;
-                else if (4 === kind) value = desc.set;
-                var newValue, get, set;
-                if ("function" == typeof decs) {
-                    newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
-                    if (void 0 !== newValue) {
-                        assertValidReturnValue(kind, newValue);
-                        if (0 === kind) init = newValue;
-                        else if (1 === kind) {
-                            init = newValue.init;
-                            get = newValue.get || value.get;
-                            set = newValue.set || value.set;
-                            value = {
-                                get: get,
-                                set: set
-                            };
-                        } else value = newValue;
+        }
+        function applyMemberDecs(Class, decInfos, metadata) {
+            var ret = [];
+            var protoInitializers;
+            var staticInitializers;
+            var existingProtoNonFields = new Map();
+            var existingStaticNonFields = new Map();
+            for(var i = 0; i < decInfos.length; i++){
+                var decInfo = decInfos[i];
+                if (Array.isArray(decInfo)) {
+                    var kind = decInfo[1];
+                    var name = decInfo[2];
+                    var isPrivate = decInfo.length > 3;
+                    var isStatic = kind >= 5;
+                    var base;
+                    var initializers;
+                    if (isStatic) {
+                        base = Class;
+                        kind -= 5;
+                        staticInitializers = staticInitializers || [];
+                        initializers = staticInitializers;
+                    } else {
+                        base = Class.prototype;
+                        protoInitializers = protoInitializers || [];
+                        initializers = protoInitializers;
                     }
-                } else for(var i = decs.length - 1; i >= 0; i--){
-                    var dec = decs[i];
-                    newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
-                    if (void 0 !== newValue) {
-                        assertValidReturnValue(kind, newValue);
-                        var newInit;
-                        if (0 === kind) newInit = newValue;
-                        else if (1 === kind) {
-                            newInit = newValue.init;
-                            get = newValue.get || value.get;
-                            set = newValue.set || value.set;
-                            value = {
-                                get: get,
-                                set: set
-                            };
-                        } else value = newValue;
-                        if (void 0 !== newInit) if (void 0 === init) init = newInit;
-                        else if ("function" == typeof init) init = [
-                            init,
-                            newInit
-                        ];
-                        else init.push(newInit);
+                    if (0 !== kind && !isPrivate) {
+                        var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                        var existingKind = existingNonFields.get(name) || 0;
+                        if (true === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                        if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+                        else existingNonFields.set(name, true);
                     }
+                    applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
                 }
-                if (0 === kind || 1 === kind) {
-                    if (void 0 === init) init = function(instance, init) {
-                        return init;
+            }
+            pushInitializers(ret, protoInitializers);
+            pushInitializers(ret, staticInitializers);
+            return ret;
+        }
+        function pushInitializers(ret, initializers) {
+            if (initializers) ret.push(function(instance) {
+                for(var i = 0; i < initializers.length; i++)initializers[i].call(instance);
+                return instance;
+            });
+        }
+        function applyClassDecs(targetClass, classDecs, metadata) {
+            if (classDecs.length > 0) {
+                var initializers = [];
+                var newClass = targetClass;
+                var name = targetClass.name;
+                for(var i = classDecs.length - 1; i >= 0; i--){
+                    var decoratorFinishedRef = {
+                        v: false
                     };
-                    else if ("function" != typeof init) {
-                        var ownInitializers = init;
-                        init = function(instance, init) {
-                            var value = init;
-                            for(var i = 0; i < ownInitializers.length; i++)value = ownInitializers[i].call(instance, value);
-                            return value;
-                        };
-                    } else {
-                        var originalInitializer = init;
-                        init = function(instance, init) {
-                            return originalInitializer.call(instance, init);
-                        };
-                    }
-                    ret.push(init);
-                }
-                if (0 !== kind) {
-                    if (1 === kind) {
-                        desc.get = value.get;
-                        desc.set = value.set;
-                    } else if (2 === kind) desc.value = value;
-                    else if (3 === kind) desc.get = value;
-                    else if (4 === kind) desc.set = value;
-                    if (isPrivate) if (1 === kind) {
-                        ret.push(function(instance, args) {
-                            return value.get.call(instance, args);
-                        });
-                        ret.push(function(instance, args) {
-                            return value.set.call(instance, args);
+                    try {
+                        var nextNewClass = classDecs[i](newClass, {
+                            kind: "class",
+                            name: name,
+                            addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                            metadata
                         });
-                    } else if (2 === kind) ret.push(value);
-                    else ret.push(function(instance, args) {
-                        return value.call(instance, args);
-                    });
-                    else Object.defineProperty(base, name, desc);
-                }
-            }
-            function applyMemberDecs(Class, decInfos, metadata) {
-                var ret = [];
-                var protoInitializers;
-                var staticInitializers;
-                var existingProtoNonFields = new Map();
-                var existingStaticNonFields = new Map();
-                for(var i = 0; i < decInfos.length; i++){
-                    var decInfo = decInfos[i];
-                    if (Array.isArray(decInfo)) {
-                        var kind = decInfo[1];
-                        var name = decInfo[2];
-                        var isPrivate = decInfo.length > 3;
-                        var isStatic = kind >= 5;
-                        var base;
-                        var initializers;
-                        if (isStatic) {
-                            base = Class;
-                            kind -= 5;
-                            staticInitializers = staticInitializers || [];
-                            initializers = staticInitializers;
-                        } else {
-                            base = Class.prototype;
-                            protoInitializers = protoInitializers || [];
-                            initializers = protoInitializers;
-                        }
-                        if (0 !== kind && !isPrivate) {
-                            var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
-                            var existingKind = existingNonFields.get(name) || 0;
-                            if (true === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
-                            if (!existingKind && kind > 2) existingNonFields.set(name, kind);
-                            else existingNonFields.set(name, true);
-                        }
-                        applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+                    } finally{
+                        decoratorFinishedRef.v = true;
                     }
-                }
-                pushInitializers(ret, protoInitializers);
-                pushInitializers(ret, staticInitializers);
-                return ret;
-            }
-            function pushInitializers(ret, initializers) {
-                if (initializers) ret.push(function(instance) {
-                    for(var i = 0; i < initializers.length; i++)initializers[i].call(instance);
-                    return instance;
-                });
-            }
-            function applyClassDecs(targetClass, classDecs, metadata) {
-                if (classDecs.length > 0) {
-                    var initializers = [];
-                    var newClass = targetClass;
-                    var name = targetClass.name;
-                    for(var i = classDecs.length - 1; i >= 0; i--){
-                        var decoratorFinishedRef = {
-                            v: false
-                        };
-                        try {
-                            var nextNewClass = classDecs[i](newClass, {
-                                kind: "class",
-                                name: name,
-                                addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
-                                metadata
-                            });
-                        } finally{
-                            decoratorFinishedRef.v = true;
-                        }
-                        if (void 0 !== nextNewClass) {
-                            assertValidReturnValue(10, nextNewClass);
-                            newClass = nextNewClass;
-                        }
+                    if (void 0 !== nextNewClass) {
+                        assertValidReturnValue(10, nextNewClass);
+                        newClass = nextNewClass;
                     }
-                    return [
-                        defineMetadata(newClass, metadata),
-                        function() {
-                            for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
-                        }
-                    ];
                 }
-            }
-            function defineMetadata(Class, metadata) {
-                return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
-                    configurable: true,
-                    enumerable: true,
-                    value: metadata
-                });
-            }
-            return function(targetClass, memberDecs, classDecs, parentClass) {
-                if (void 0 !== parentClass) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
-                var metadata = Object.create(void 0 === parentMetadata ? null : parentMetadata);
-                var e = applyMemberDecs(targetClass, memberDecs, metadata);
-                if (!classDecs.length) defineMetadata(targetClass, metadata);
-                return {
-                    e: e,
-                    get c () {
-                        return applyClassDecs(targetClass, classDecs, metadata);
+                return [
+                    defineMetadata(newClass, metadata),
+                    function() {
+                        for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
                     }
-                };
-            };
-        }
-        function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
-            return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
-        }
-        var _dec, _dec1, _dec2, _dec3, _initProto;
-        const logger = (0, dist.zP)('Analytics');
-        const MAX_QUEUED_EVENTS = 25;
-        _dec = (0, guardedBy.i)('isNotDuplicated', {
-            onBlocked: 'onBlockedByDuplication'
-        }), _dec1 = (0, guardedBy.i)('hasConsent', {
-            onBlocked: 'onBlockedByConsent'
-        }), _dec2 = (0, guardedBy.i)('isNotDuplicated', {
-            onBlocked: 'onBlockedByDuplication'
-        }), _dec3 = (0, guardedBy.i)('hasConsent', {
-            onBlocked: 'onBlockedByConsent'
-        });
-        class AnalyticsStateful extends analytics_AnalyticsBase {
-            static{
-                ({ e: [_initProto] } = _apply_decs_2203_r(this, [
-                    [
-                        [
-                            _dec,
-                            _dec1
-                        ],
-                        2,
-                        "trackComponentView"
-                    ],
-                    [
-                        [
-                            _dec2,
-                            _dec3
-                        ],
-                        2,
-                        "trackFlagView"
-                    ]
-                ], []));
+                ];
             }
-            queue = (_initProto(this), new Map());
-            states = {
-                eventStream: (0, signals.br)(signals.f0),
-                profile: (0, signals.br)(signals.ME)
+        }
+        function defineMetadata(Class, metadata) {
+            return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+                configurable: true,
+                enumerable: true,
+                value: metadata
+            });
+        }
+        return function(targetClass, memberDecs, classDecs, parentClass) {
+            if (void 0 !== parentClass) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+            var metadata = Object.create(void 0 === parentMetadata ? null : parentMetadata);
+            var e = applyMemberDecs(targetClass, memberDecs, metadata);
+            if (!classDecs.length) defineMetadata(targetClass, metadata);
+            return {
+                e: e,
+                get c () {
+                    return applyClassDecs(targetClass, classDecs, metadata);
+                }
             };
-            constructor(options){
-                const { api, builder, config, interceptors } = options;
-                super({
-                    api,
-                    builder,
-                    config,
-                    interceptors
-                });
-                const { defaults } = config ?? {};
-                if (defaults?.profile !== void 0) {
-                    const { profile: defaultProfile } = defaults;
-                    signals.ME.value = defaultProfile;
+        };
+    }
+    function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+        return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+    }
+    var _dec, _dec1, _dec2, _dec3, _initProto;
+    const AnalyticsStateful_logger = (0, logger_namespaceObject.createScopedLogger)('Analytics');
+    const MAX_QUEUED_EVENTS = 25;
+    const ANALYTICS_METHOD_EVENT_TYPE_MAP = {
+        trackComponentView: 'component',
+        trackFlagView: 'component',
+        trackComponentClick: 'component_click',
+        trackComponentHover: 'component_hover'
+    };
+    _dec = guardedBy('hasConsent', {
+        onBlocked: 'onBlockedByConsent'
+    }), _dec1 = guardedBy('hasConsent', {
+        onBlocked: 'onBlockedByConsent'
+    }), _dec2 = guardedBy('hasConsent', {
+        onBlocked: 'onBlockedByConsent'
+    }), _dec3 = guardedBy('hasConsent', {
+        onBlocked: 'onBlockedByConsent'
+    });
+    class AnalyticsStateful extends analytics_AnalyticsBase {
+        static{
+            ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+                [
+                    _dec,
+                    2,
+                    "trackComponentView"
+                ],
+                [
+                    _dec1,
+                    2,
+                    "trackComponentClick"
+                ],
+                [
+                    _dec2,
+                    2,
+                    "trackComponentHover"
+                ],
+                [
+                    _dec3,
+                    2,
+                    "trackFlagView"
+                ]
+            ], []));
+        }
+        queue = (_initProto(this), new Map());
+        flushRuntime;
+        states = {
+            blockedEventStream: toObservable(blockedEvent),
+            eventStream: toObservable(signals_event),
+            profile: toObservable(signals_profile)
+        };
+        constructor(options){
+            const { api, builder, config, interceptors } = options;
+            super({
+                api,
+                builder,
+                config,
+                interceptors
+            });
+            this.applyDefaults(config?.defaults);
+            this.flushRuntime = new QueueFlushRuntime({
+                policy: resolveQueueFlushPolicy(config?.queuePolicy),
+                onRetry: ()=>{
+                    this.flush();
+                },
+                onCallbackError: (callbackName, error)=>{
+                    AnalyticsStateful_logger.warn(`Analytics flush policy callback "${callbackName}" failed`, error);
                 }
-                (0, signals.QZ)(()=>{
-                    const id = signals.ME.value?.id;
-                    logger.info(`Analytics ${signals.vJ.value ? 'will' : 'will not'} be collected due to consent (${signals.vJ.value})`);
-                    logger.debug(`Profile ${id && `with ID ${id}`} has been ${id ? 'set' : 'cleared'}`);
-                });
-                (0, signals.QZ)(()=>{
-                    if (signals.WD.value) this.flush();
+            });
+            this.initializeEffects();
+        }
+        reset() {
+            this.flushRuntime.reset();
+            (0, signals_core_namespaceObject.batch)(()=>{
+                blockedEvent.value = void 0;
+                signals_event.value = void 0;
+                signals_profile.value = void 0;
+            });
+        }
+        hasConsent(name) {
+            const mappedEventType = ANALYTICS_METHOD_EVENT_TYPE_MAP[name] ?? name;
+            return !!consent.value || (this.allowedEventTypes ?? []).includes(mappedEventType);
+        }
+        onBlockedByConsent(name, payload) {
+            AnalyticsStateful_logger.warn(`Event "${name}" was blocked due to lack of consent; payload: ${JSON.stringify(payload)}`);
+            this.reportBlockedEvent('consent', 'analytics', name, payload);
+        }
+        async trackComponentView(payload) {
+            AnalyticsStateful_logger.info(`Processing "component view" event for ${payload.componentId}`);
+            await this.enqueueEvent(this.builder.buildComponentView(payload));
+        }
+        async trackComponentClick(payload) {
+            AnalyticsStateful_logger.info(`Processing "component click" event for ${payload.componentId}`);
+            await this.enqueueEvent(this.builder.buildComponentClick(payload));
+        }
+        async trackComponentHover(payload) {
+            AnalyticsStateful_logger.info(`Processing "component hover" event for ${payload.componentId}`);
+            await this.enqueueEvent(this.builder.buildComponentHover(payload));
+        }
+        async trackFlagView(payload) {
+            AnalyticsStateful_logger.debug(`Processing "flag view" event for ${payload.componentId}`);
+            await this.enqueueEvent(this.builder.buildFlagView(payload));
+        }
+        async enqueueEvent(event) {
+            const { value: profile } = signals_profile;
+            if (!profile) return void AnalyticsStateful_logger.warn('Attempting to emit an event without an Optimization profile');
+            const intercepted = await this.interceptors.event.run(event);
+            const validEvent = (0, api_schemas_namespaceObject.parseWithFriendlyError)(api_schemas_namespaceObject.InsightsEvent, intercepted);
+            AnalyticsStateful_logger.debug(`Queueing ${validEvent.type} event for profile ${profile.id}`, validEvent);
+            const { id: profileId } = profile;
+            const queuedProfileEvents = this.queue.get(profileId);
+            signals_event.value = validEvent;
+            if (queuedProfileEvents) {
+                queuedProfileEvents.profile = profile;
+                queuedProfileEvents.events.push(validEvent);
+            } else this.queue.set(profileId, {
+                profile,
+                events: [
+                    validEvent
+                ]
+            });
+            await this.flushMaxEvents();
+        }
+        async flushMaxEvents() {
+            if (this.getQueuedEventCount() >= MAX_QUEUED_EVENTS) await this.flush();
+        }
+        async flush(options = {}) {
+            const { force = false } = options;
+            if (this.flushRuntime.shouldSkip({
+                force,
+                isOnline: !!online.value
+            })) return;
+            AnalyticsStateful_logger.debug('Flushing event queue');
+            const batches = this.createBatches();
+            if (!batches.length) return void this.flushRuntime.clearScheduledRetry();
+            this.flushRuntime.markFlushStarted();
+            try {
+                const sendSuccess = await this.trySendBatches(batches);
+                if (sendSuccess) {
+                    this.queue.clear();
+                    this.flushRuntime.handleFlushSuccess();
+                } else this.flushRuntime.handleFlushFailure({
+                    queuedBatches: batches.length,
+                    queuedEvents: this.getQueuedEventCount()
                 });
+            } finally{
+                this.flushRuntime.markFlushFinished();
             }
-            reset() {
-                (0, signals.vA)(()=>{
-                    signals.f0.value = void 0;
-                    signals.ME.value = void 0;
+        }
+        applyDefaults(defaults) {
+            if (defaults?.profile === void 0) return;
+            const { profile: defaultProfile } = defaults;
+            signals_profile.value = defaultProfile;
+        }
+        initializeEffects() {
+            (0, signals_core_namespaceObject.effect)(()=>{
+                const id = signals_profile.value?.id;
+                AnalyticsStateful_logger.info(`Analytics ${consent.value ? 'will' : 'will not'} be collected due to consent (${consent.value})`);
+                AnalyticsStateful_logger.debug(`Profile ${id && `with ID ${id}`} has been ${id ? 'set' : 'cleared'}`);
+            });
+            (0, signals_core_namespaceObject.effect)(()=>{
+                if (!online.value) return;
+                this.flushRuntime.clearScheduledRetry();
+                this.flush({
+                    force: true
                 });
-            }
-            hasConsent(name) {
-                return !!signals.vJ.value || (this.allowedEventTypes ?? []).includes('trackComponentView' === name || 'trackFlagView' === name ? 'component' : name);
-            }
-            onBlockedByConsent(name, payload) {
-                logger.warn(`Event "${name}" was blocked due to lack of consent; payload: ${JSON.stringify(payload)}`);
-            }
-            isNotDuplicated(_name, payload) {
-                const [{ componentId: value }, duplicationScope] = payload;
-                const isDuplicated = this.duplicationDetector.isPresent(duplicationScope, value);
-                if (!isDuplicated) this.duplicationDetector.addValue(duplicationScope, value);
-                return !isDuplicated;
-            }
-            onBlockedByDuplication(name, payload) {
-                const componentType = 'trackFlagView' === name ? 'flag' : 'component';
-                logger.debug(`Duplicate "${componentType} view" event detected, skipping; payload: ${JSON.stringify(payload)}`);
-            }
-            async trackComponentView(payload, _duplicationScope = '') {
-                logger.info(`Processing "component view" event for ${payload.componentId}`);
-                await this.enqueueEvent(this.builder.buildComponentView(payload));
-            }
-            async trackFlagView(payload, _duplicationScope = '') {
-                logger.debug(`Processing "flag view" event for ${payload.componentId}`);
-                await this.enqueueEvent(this.builder.buildFlagView(payload));
-            }
-            async enqueueEvent(event) {
-                const { value: profile } = signals.ME;
-                if (!profile) return void logger.warn('Attempting to emit an event without an Optimization profile');
-                const intercepted = await this.interceptors.event.run(event);
-                const validEvent = optimization_api_client_.InsightsEvent.parse(intercepted);
-                logger.debug(`Queueing ${validEvent.type} event for profile ${profile.id}`, validEvent);
-                const profileEventQueue = this.queue.get(profile);
-                signals.f0.value = validEvent;
-                if (profileEventQueue) profileEventQueue.push(validEvent);
-                else this.queue.set(profile, [
-                    validEvent
-                ]);
-                await this.flushMaxEvents();
-            }
-            async flushMaxEvents() {
-                if (this.queue.values().toArray().flat().length >= MAX_QUEUED_EVENTS) await this.flush();
-            }
-            async flush() {
-                logger.debug('Flushing event queue');
-                const batches = [];
-                this.queue.forEach((events, profile)=>batches.push({
-                        profile,
-                        events
-                    }));
-                if (!batches.length) return;
-                const sendSuccess = await this.api.insights.sendBatchEvents(batches);
-                if (sendSuccess) this.queue.clear();
-            }
+            });
         }
-        const analytics_AnalyticsStateful = AnalyticsStateful;
-        const AnalyticsStateless_logger = (0, dist.zP)('Analytics');
-        class AnalyticsStateless extends analytics_AnalyticsBase {
-            async trackComponentView(args) {
-                AnalyticsStateless_logger.info('Processing "component view" event');
-                const { profile, ...builderArgs } = args;
-                const event = this.builder.buildComponentView(builderArgs);
-                const intercepted = await this.interceptors.event.run(event);
-                const parsed = optimization_api_client_.ComponentViewEvent.parse(intercepted);
-                await this.sendBatchEvent(parsed, profile);
-            }
-            async trackFlagView(args) {
-                AnalyticsStateless_logger.debug('Processing "flag view" event');
-                const { profile, ...builderArgs } = args;
-                const event = this.builder.buildFlagView(builderArgs);
-                const intercepted = await this.interceptors.event.run(event);
-                const parsed = optimization_api_client_.ComponentViewEvent.parse(intercepted);
-                await this.sendBatchEvent(parsed, profile);
-            }
-            async sendBatchEvent(event, profile) {
-                const batchEvent = optimization_api_client_.BatchInsightsEventArray.parse([
-                    {
-                        profile,
-                        events: [
-                            event
-                        ]
-                    }
-                ]);
-                await this.api.insights.sendBatchEvents(batchEvent);
+        createBatches() {
+            const batches = [];
+            this.queue.forEach(({ profile, events })=>{
+                batches.push({
+                    profile,
+                    events
+                });
+            });
+            return batches;
+        }
+        async trySendBatches(batches) {
+            try {
+                return await this.api.insights.sendBatchEvents(batches);
+            } catch (error) {
+                AnalyticsStateful_logger.warn('Analytics queue flush request threw an error', error);
+                return false;
             }
         }
-        const analytics_AnalyticsStateless = AnalyticsStateless;
-    },
-    "./src/global-constants.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            E: ()=>OPTIMIZATION_CORE_SDK_VERSION,
-            T: ()=>ANONYMOUS_ID_COOKIE
-        });
-        const OPTIMIZATION_CORE_SDK_VERSION = "0.1.0-alpha";
-        const ANONYMOUS_ID_COOKIE = 'ctfl-opt-aid';
-    },
-    "./src/lib/decorators/guardedBy.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            i: ()=>guardedBy
-        });
-        const isFunction = (v)=>'function' == typeof v;
-        const nameToString = (name)=>'string' == typeof name ? name : 'symbol' == typeof name ? name.description ?? String(name) : String(name);
-        const isOnBlockedKey = (v)=>'string' == typeof v || 'symbol' == typeof v;
-        const isAsyncFunction = (fn)=>'[object AsyncFunction]' === Object.prototype.toString.call(fn);
-        function guardedBy(predicateName, opts) {
-            return function(_value, context) {
-                const decoratedName = nameToString(context.name);
-                context.addInitializer(function() {
-                    const originalUnknown = Reflect.get(this, context.name);
-                    if (!isFunction(originalUnknown)) return;
-                    const original = originalUnknown;
-                    const originalIsAsync = isAsyncFunction(original);
-                    const resolvePredicate = (self)=>{
-                        const { [predicateName]: cand } = self;
-                        if (!isFunction(cand)) throw new TypeError(`@guardedBy expects predicate "${String(predicateName)}" to be a synchronous function.`);
-                        return cand;
-                    };
-                    const computeAllowed = (self, args)=>{
-                        const pred = resolvePredicate(self);
-                        const ok = Boolean(pred.call(self, decoratedName, args));
-                        return opts?.invert === true ? !ok : ok;
-                    };
-                    const runOnBlocked = (self, args)=>{
-                        const { onBlocked } = opts ?? {};
-                        if (void 0 === onBlocked) return;
-                        if (isFunction(onBlocked)) return void onBlocked.call(self, decoratedName, args);
-                        if (isOnBlockedKey(onBlocked)) {
-                            const { [onBlocked]: handlerCandidate } = self;
-                            if (isFunction(handlerCandidate)) handlerCandidate.call(self, decoratedName, args);
-                        }
-                    };
-                    const blockedReturn = ()=>originalIsAsync ? Promise.resolve(void 0) : void 0;
-                    const wrapped = function(...args) {
-                        if (!computeAllowed(this, args)) {
-                            runOnBlocked(this, args);
-                            return blockedReturn();
-                        }
-                        return original.call(this, ...args);
-                    };
-                    Reflect.set(this, context.name, wrapped);
-                });
+        getQueuedEventCount() {
+            let queuedCount = 0;
+            this.queue.forEach(({ events })=>{
+                queuedCount += events.length;
+            });
+            return queuedCount;
+        }
+    }
+    const analytics_AnalyticsStateful = AnalyticsStateful;
+    const AnalyticsStateless_logger = (0, logger_namespaceObject.createScopedLogger)('Analytics');
+    class AnalyticsStateless extends analytics_AnalyticsBase {
+        async trackComponentView(args) {
+            AnalyticsStateless_logger.info('Processing "component view" event');
+            const { profile, ...builderArgs } = args;
+            const event = this.builder.buildComponentView(builderArgs);
+            await this.sendBatchEvent(event, profile);
+        }
+        async trackComponentClick(args) {
+            AnalyticsStateless_logger.info('Processing "component click" event');
+            const { profile, ...builderArgs } = args;
+            const event = this.builder.buildComponentClick(builderArgs);
+            await this.sendBatchEvent(event, profile);
+        }
+        async trackComponentHover(args) {
+            AnalyticsStateless_logger.info('Processing "component hover" event');
+            const { profile, ...builderArgs } = args;
+            const event = this.builder.buildComponentHover(builderArgs);
+            await this.sendBatchEvent(event, profile);
+        }
+        async trackFlagView(args) {
+            AnalyticsStateless_logger.debug('Processing "flag view" event');
+            const { profile, ...builderArgs } = args;
+            const event = this.builder.buildFlagView(builderArgs);
+            await this.sendBatchEvent(event, profile);
+        }
+        async sendBatchEvent(event, profile) {
+            const intercepted = await this.interceptors.event.run(event);
+            const parsed = (0, api_schemas_namespaceObject.parseWithFriendlyError)(api_schemas_namespaceObject.InsightsEvent, intercepted);
+            const batchEvent = (0, api_schemas_namespaceObject.parseWithFriendlyError)(api_schemas_namespaceObject.BatchInsightsEventArray, [
+                {
+                    profile,
+                    events: [
+                        parsed
+                    ]
+                }
+            ]);
+            await this.api.insights.sendBatchEvents(batchEvent);
+        }
+    }
+    const analytics_AnalyticsStateless = AnalyticsStateless;
+    var constants = __webpack_require__("./src/constants.ts");
+    const optimization_api_client_namespaceObject = require("@contentful/optimization-api-client");
+    class InterceptorManager {
+        interceptors = new Map();
+        nextId = 0;
+        add(interceptor) {
+            const { nextId: id } = this;
+            this.nextId += 1;
+            this.interceptors.set(id, interceptor);
+            return id;
+        }
+        remove(id) {
+            return this.interceptors.delete(id);
+        }
+        clear() {
+            this.interceptors.clear();
+        }
+        count() {
+            return this.interceptors.size;
+        }
+        async run(input) {
+            const fns = Array.from(this.interceptors.values());
+            let acc = input;
+            for (const fn of fns)acc = await fn(acc);
+            return acc;
+        }
+    }
+    class CoreBase {
+        api;
+        eventBuilder;
+        config;
+        interceptors = {
+            event: new InterceptorManager(),
+            state: new InterceptorManager()
+        };
+        constructor(config){
+            this.config = config;
+            const { analytics, personalization, eventBuilder, logLevel, environment, clientId, fetchOptions } = config;
+            logger_namespaceObject.logger.addSink(new logger_namespaceObject.ConsoleLogSink(logLevel));
+            const apiConfig = {
+                clientId,
+                environment,
+                fetchOptions,
+                analytics,
+                personalization
             };
+            this.api = new optimization_api_client_namespaceObject.ApiClient(apiConfig);
+            this.eventBuilder = new optimization_api_client_namespaceObject.EventBuilder(eventBuilder ?? {
+                channel: 'server',
+                library: {
+                    name: constants.OPTIMIZATION_CORE_SDK_NAME,
+                    version: constants.OPTIMIZATION_CORE_SDK_VERSION
+                }
+            });
         }
-    },
-    "./src/lib/decorators/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            i: ()=>_guardedBy__rspack_import_0.i
-        });
-        var _guardedBy__rspack_import_0 = __webpack_require__("./src/lib/decorators/guardedBy.ts");
-    },
-    "./src/lib/interceptor/InterceptorManager.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            v: ()=>InterceptorManager
-        });
-        class InterceptorManager {
-            interceptors = new Map();
-            nextId = 0;
-            add(interceptor) {
-                const { nextId: id } = this;
-                this.nextId += 1;
-                this.interceptors.set(id, interceptor);
-                return id;
-            }
-            remove(id) {
-                return this.interceptors.delete(id);
-            }
-            clear() {
-                this.interceptors.clear();
-            }
-            count() {
-                return this.interceptors.size;
-            }
-            async run(input) {
-                const fns = Array.from(this.interceptors.values());
-                let acc = input;
-                for (const fn of fns)acc = await fn(acc);
-                return acc;
-            }
+        get flagsResolver() {
+            return this._personalization.flagsResolver;
         }
-    },
-    "./src/lib/interceptor/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            v: ()=>_InterceptorManager__rspack_import_0.v
-        });
-        var _InterceptorManager__rspack_import_0 = __webpack_require__("./src/lib/interceptor/InterceptorManager.ts");
-    },
-    "./src/lib/value-presence/ValuePresence.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            A: ()=>__rspack_default_export
-        });
-        class ValuePresence {
-            #map;
-            constructor(defaultMap){
-                const map = new Map();
-                if (defaultMap) Object.entries(defaultMap).map(([scope, values])=>map.set(scope.length ? scope : void 0, new Set(values)));
-                this.#map = map;
-            }
-            isPresent(scope, value) {
-                return this.#map.get(scope)?.has(value) ?? false;
-            }
-            addValue(scope, value) {
-                const values = this.#map.get(scope);
-                if (values) values.add(value);
-                else this.#map.set(scope, new Set([
-                    value
-                ]));
-            }
-            removeValue(scope, value) {
-                this.#map.get(scope)?.delete(value);
-            }
-            reset(scope) {
-                if (void 0 !== scope) this.#map.get(scope)?.clear();
-                else this.#map.clear();
-            }
+        get mergeTagValueResolver() {
+            return this._personalization.mergeTagValueResolver;
         }
-        const __rspack_default_export = ValuePresence;
-    },
-    "./src/lib/value-presence/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            n: ()=>_ValuePresence__rspack_import_0.A
-        });
-        var _ValuePresence__rspack_import_0 = __webpack_require__("./src/lib/value-presence/ValuePresence.ts");
-    },
-    "./src/personalization/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            OR: ()=>resolvers.OR,
-            $C: ()=>personalization_PersonalizationStateful,
-            jL: ()=>personalization_PersonalizationStateless,
-            cv: ()=>resolvers.cv,
-            z8: ()=>resolvers.z8
-        });
-        var resolvers = __webpack_require__("./src/personalization/resolvers/index.ts");
-        var optimization_api_client_ = __webpack_require__("@contentful/optimization-api-client");
-        const external_es_toolkit_namespaceObject = require("es-toolkit");
-        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
-        var guardedBy = __webpack_require__("./src/lib/decorators/guardedBy.ts");
-        var signals = __webpack_require__("./src/signals.ts");
-        var ProductBase = __webpack_require__("./src/ProductBase.ts");
-        class PersonalizationBase extends ProductBase.A {
-            flagsResolver = resolvers.OR;
-            mergeTagValueResolver = resolvers.cv;
-            personalizedEntryResolver = resolvers.z8;
-            getCustomFlag(name, changes) {
-                return resolvers.OR.resolve(changes)[name];
+        get personalizedEntryResolver() {
+            return this._personalization.personalizedEntryResolver;
+        }
+        getCustomFlag(name, changes) {
+            return this._personalization.getCustomFlag(name, changes);
+        }
+        getCustomFlags(changes) {
+            return this._personalization.getCustomFlags(changes);
+        }
+        personalizeEntry(entry, personalizations) {
+            return this._personalization.personalizeEntry(entry, personalizations);
+        }
+        getMergeTagValue(embeddedEntryNodeTarget, profile) {
+            return this._personalization.getMergeTagValue(embeddedEntryNodeTarget, profile);
+        }
+        async identify(payload) {
+            return await this._personalization.identify(payload);
+        }
+        async page(payload) {
+            return await this._personalization.page(payload);
+        }
+        async screen(payload) {
+            return await this._personalization.screen(payload);
+        }
+        async track(payload) {
+            return await this._personalization.track(payload);
+        }
+        async trackComponentView(payload) {
+            if (payload.sticky) return await this._personalization.trackComponentView(payload);
+            await this._analytics.trackComponentView(payload);
+        }
+        async trackComponentClick(payload) {
+            await this._analytics.trackComponentClick(payload);
+        }
+        async trackComponentHover(payload) {
+            await this._analytics.trackComponentHover(payload);
+        }
+        async trackFlagView(payload) {
+            await this._analytics.trackFlagView(payload);
+        }
+    }
+    const src_CoreBase = CoreBase;
+    const STATEFUL_RUNTIME_LOCK_KEY = '__ctfl_optimization_stateful_runtime_lock__';
+    const getStatefulRuntimeLock = ()=>{
+        const singletonGlobal = globalThis;
+        singletonGlobal[STATEFUL_RUNTIME_LOCK_KEY] ??= {
+            owner: void 0
+        };
+        return singletonGlobal[STATEFUL_RUNTIME_LOCK_KEY];
+    };
+    const acquireStatefulRuntimeSingleton = (owner)=>{
+        const lock = getStatefulRuntimeLock();
+        if (lock.owner) throw new Error(`Stateful Optimization SDK already initialized (${lock.owner}). Only one stateful instance is supported per runtime.`);
+        lock.owner = owner;
+    };
+    const releaseStatefulRuntimeSingleton = (owner)=>{
+        const lock = getStatefulRuntimeLock();
+        if (lock.owner === owner) lock.owner = void 0;
+    };
+    class PersonalizationBase extends src_ProductBase {
+        flagsResolver = resolvers_FlagsResolver;
+        mergeTagValueResolver = resolvers_MergeTagValueResolver;
+        personalizedEntryResolver = resolvers_PersonalizedEntryResolver;
+        getCustomFlag(name, changes) {
+            return this.getCustomFlags(changes)[name];
+        }
+        getCustomFlags(changes) {
+            return resolvers_FlagsResolver.resolve(changes);
+        }
+        personalizeEntry(entry, personalizations) {
+            return resolvers_PersonalizedEntryResolver.resolve(entry, personalizations);
+        }
+        getMergeTagValue(embeddedEntryNodeTarget, profile) {
+            return resolvers_MergeTagValueResolver.resolve(embeddedEntryNodeTarget, profile);
+        }
+    }
+    const personalization_PersonalizationBase = PersonalizationBase;
+    const predicate_namespaceObject = require("es-toolkit/predicate");
+    function PersonalizationStateful_applyDecs2203RFactory() {
+        function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+            return function(initializer) {
+                assertNotFinished(decoratorFinishedRef, "addInitializer");
+                assertCallable(initializer, "An initializer");
+                initializers.push(initializer);
+            };
+        }
+        function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+            var kindStr;
+            switch(kind){
+                case 1:
+                    kindStr = "accessor";
+                    break;
+                case 2:
+                    kindStr = "method";
+                    break;
+                case 3:
+                    kindStr = "getter";
+                    break;
+                case 4:
+                    kindStr = "setter";
+                    break;
+                default:
+                    kindStr = "field";
+            }
+            var ctx = {
+                kind: kindStr,
+                name: isPrivate ? "#" + name : name,
+                static: isStatic,
+                private: isPrivate,
+                metadata: metadata
+            };
+            var decoratorFinishedRef = {
+                v: false
+            };
+            ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+            var get, set;
+            if (0 === kind) if (isPrivate) {
+                get = desc.get;
+                set = desc.set;
+            } else {
+                get = function() {
+                    return this[name];
+                };
+                set = function(v) {
+                    this[name] = v;
+                };
             }
-            personalizeEntry(entry, personalizations) {
-                return resolvers.z8.resolve(entry, personalizations);
+            else if (2 === kind) get = function() {
+                return desc.value;
+            };
+            else {
+                if (1 === kind || 3 === kind) get = function() {
+                    return desc.get.call(this);
+                };
+                if (1 === kind || 4 === kind) set = function(v) {
+                    desc.set.call(this, v);
+                };
             }
-            getMergeTagValue(embeddedEntryNodeTarget, profile) {
-                return resolvers.cv.resolve(embeddedEntryNodeTarget, profile);
+            ctx.access = get && set ? {
+                get: get,
+                set: set
+            } : get ? {
+                get: get
+            } : {
+                set: set
+            };
+            try {
+                return dec(value, ctx);
+            } finally{
+                decoratorFinishedRef.v = true;
             }
         }
-        const personalization_PersonalizationBase = PersonalizationBase;
-        function applyDecs2203RFactory() {
-            function createAddInitializerMethod(initializers, decoratorFinishedRef) {
-                return function(initializer) {
-                    assertNotFinished(decoratorFinishedRef, "addInitializer");
-                    assertCallable(initializer, "An initializer");
-                    initializers.push(initializer);
-                };
+        function assertNotFinished(decoratorFinishedRef, fnName) {
+            if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+        }
+        function assertCallable(fn, hint) {
+            if ("function" != typeof fn) throw new TypeError(hint + " must be a function");
+        }
+        function assertValidReturnValue(kind, value) {
+            var type = typeof value;
+            if (1 === kind) {
+                if ("object" !== type || null === value) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+                if (void 0 !== value.get) assertCallable(value.get, "accessor.get");
+                if (void 0 !== value.set) assertCallable(value.set, "accessor.set");
+                if (void 0 !== value.init) assertCallable(value.init, "accessor.init");
+            } else if ("function" !== type) {
+                var hint;
+                hint = 0 === kind ? "field" : 10 === kind ? "class" : "method";
+                throw new TypeError(hint + " decorators must return a function or void 0");
             }
-            function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
-                var kindStr;
-                switch(kind){
-                    case 1:
-                        kindStr = "accessor";
-                        break;
-                    case 2:
-                        kindStr = "method";
-                        break;
-                    case 3:
-                        kindStr = "getter";
-                        break;
-                    case 4:
-                        kindStr = "setter";
-                        break;
-                    default:
-                        kindStr = "field";
+        }
+        function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+            var decs = decInfo[0];
+            var desc, init, value;
+            if (isPrivate) desc = 0 === kind || 1 === kind ? {
+                get: decInfo[3],
+                set: decInfo[4]
+            } : 3 === kind ? {
+                get: decInfo[3]
+            } : 4 === kind ? {
+                set: decInfo[3]
+            } : {
+                value: decInfo[3]
+            };
+            else if (0 !== kind) desc = Object.getOwnPropertyDescriptor(base, name);
+            if (1 === kind) value = {
+                get: desc.get,
+                set: desc.set
+            };
+            else if (2 === kind) value = desc.value;
+            else if (3 === kind) value = desc.get;
+            else if (4 === kind) value = desc.set;
+            var newValue, get, set;
+            if ("function" == typeof decs) {
+                newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                if (void 0 !== newValue) {
+                    assertValidReturnValue(kind, newValue);
+                    if (0 === kind) init = newValue;
+                    else if (1 === kind) {
+                        init = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+                        value = {
+                            get: get,
+                            set: set
+                        };
+                    } else value = newValue;
                 }
-                var ctx = {
-                    kind: kindStr,
-                    name: isPrivate ? "#" + name : name,
-                    static: isStatic,
-                    private: isPrivate,
-                    metadata: metadata
-                };
-                var decoratorFinishedRef = {
-                    v: false
-                };
-                ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
-                var get, set;
-                if (0 === kind) if (isPrivate) {
-                    get = desc.get;
-                    set = desc.set;
-                } else {
-                    get = function() {
-                        return this[name];
-                    };
-                    set = function(v) {
-                        this[name] = v;
-                    };
+            } else for(var i = decs.length - 1; i >= 0; i--){
+                var dec = decs[i];
+                newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                if (void 0 !== newValue) {
+                    assertValidReturnValue(kind, newValue);
+                    var newInit;
+                    if (0 === kind) newInit = newValue;
+                    else if (1 === kind) {
+                        newInit = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+                        value = {
+                            get: get,
+                            set: set
+                        };
+                    } else value = newValue;
+                    if (void 0 !== newInit) if (void 0 === init) init = newInit;
+                    else if ("function" == typeof init) init = [
+                        init,
+                        newInit
+                    ];
+                    else init.push(newInit);
                 }
-                else if (2 === kind) get = function() {
-                    return desc.value;
+            }
+            if (0 === kind || 1 === kind) {
+                if (void 0 === init) init = function(instance, init) {
+                    return init;
                 };
-                else {
-                    if (1 === kind || 3 === kind) get = function() {
-                        return desc.get.call(this);
+                else if ("function" != typeof init) {
+                    var ownInitializers = init;
+                    init = function(instance, init) {
+                        var value = init;
+                        for(var i = 0; i < ownInitializers.length; i++)value = ownInitializers[i].call(instance, value);
+                        return value;
                     };
-                    if (1 === kind || 4 === kind) set = function(v) {
-                        desc.set.call(this, v);
+                } else {
+                    var originalInitializer = init;
+                    init = function(instance, init) {
+                        return originalInitializer.call(instance, init);
                     };
                 }
-                ctx.access = get && set ? {
-                    get: get,
-                    set: set
-                } : get ? {
-                    get: get
-                } : {
-                    set: set
-                };
-                try {
-                    return dec(value, ctx);
-                } finally{
-                    decoratorFinishedRef.v = true;
-                }
+                ret.push(init);
             }
-            function assertNotFinished(decoratorFinishedRef, fnName) {
-                if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
-            }
-            function assertCallable(fn, hint) {
-                if ("function" != typeof fn) throw new TypeError(hint + " must be a function");
-            }
-            function assertValidReturnValue(kind, value) {
-                var type = typeof value;
+            if (0 !== kind) {
                 if (1 === kind) {
-                    if ("object" !== type || null === value) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
-                    if (void 0 !== value.get) assertCallable(value.get, "accessor.get");
-                    if (void 0 !== value.set) assertCallable(value.set, "accessor.set");
-                    if (void 0 !== value.init) assertCallable(value.init, "accessor.init");
-                } else if ("function" !== type) {
-                    var hint;
-                    hint = 0 === kind ? "field" : 10 === kind ? "class" : "method";
-                    throw new TypeError(hint + " decorators must return a function or void 0");
-                }
+                    desc.get = value.get;
+                    desc.set = value.set;
+                } else if (2 === kind) desc.value = value;
+                else if (3 === kind) desc.get = value;
+                else if (4 === kind) desc.set = value;
+                if (isPrivate) if (1 === kind) {
+                    ret.push(function(instance, args) {
+                        return value.get.call(instance, args);
+                    });
+                    ret.push(function(instance, args) {
+                        return value.set.call(instance, args);
+                    });
+                } else if (2 === kind) ret.push(value);
+                else ret.push(function(instance, args) {
+                    return value.call(instance, args);
+                });
+                else Object.defineProperty(base, name, desc);
             }
-            function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
-                var decs = decInfo[0];
-                var desc, init, value;
-                if (isPrivate) desc = 0 === kind || 1 === kind ? {
-                    get: decInfo[3],
-                    set: decInfo[4]
-                } : 3 === kind ? {
-                    get: decInfo[3]
-                } : 4 === kind ? {
-                    set: decInfo[3]
-                } : {
-                    value: decInfo[3]
-                };
-                else if (0 !== kind) desc = Object.getOwnPropertyDescriptor(base, name);
-                if (1 === kind) value = {
-                    get: desc.get,
-                    set: desc.set
-                };
-                else if (2 === kind) value = desc.value;
-                else if (3 === kind) value = desc.get;
-                else if (4 === kind) value = desc.set;
-                var newValue, get, set;
-                if ("function" == typeof decs) {
-                    newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
-                    if (void 0 !== newValue) {
-                        assertValidReturnValue(kind, newValue);
-                        if (0 === kind) init = newValue;
-                        else if (1 === kind) {
-                            init = newValue.init;
-                            get = newValue.get || value.get;
-                            set = newValue.set || value.set;
-                            value = {
-                                get: get,
-                                set: set
-                            };
-                        } else value = newValue;
+        }
+        function applyMemberDecs(Class, decInfos, metadata) {
+            var ret = [];
+            var protoInitializers;
+            var staticInitializers;
+            var existingProtoNonFields = new Map();
+            var existingStaticNonFields = new Map();
+            for(var i = 0; i < decInfos.length; i++){
+                var decInfo = decInfos[i];
+                if (Array.isArray(decInfo)) {
+                    var kind = decInfo[1];
+                    var name = decInfo[2];
+                    var isPrivate = decInfo.length > 3;
+                    var isStatic = kind >= 5;
+                    var base;
+                    var initializers;
+                    if (isStatic) {
+                        base = Class;
+                        kind -= 5;
+                        staticInitializers = staticInitializers || [];
+                        initializers = staticInitializers;
+                    } else {
+                        base = Class.prototype;
+                        protoInitializers = protoInitializers || [];
+                        initializers = protoInitializers;
                     }
-                } else for(var i = decs.length - 1; i >= 0; i--){
-                    var dec = decs[i];
-                    newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
-                    if (void 0 !== newValue) {
-                        assertValidReturnValue(kind, newValue);
-                        var newInit;
-                        if (0 === kind) newInit = newValue;
-                        else if (1 === kind) {
-                            newInit = newValue.init;
-                            get = newValue.get || value.get;
-                            set = newValue.set || value.set;
-                            value = {
-                                get: get,
-                                set: set
-                            };
-                        } else value = newValue;
-                        if (void 0 !== newInit) if (void 0 === init) init = newInit;
-                        else if ("function" == typeof init) init = [
-                            init,
-                            newInit
-                        ];
-                        else init.push(newInit);
+                    if (0 !== kind && !isPrivate) {
+                        var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                        var existingKind = existingNonFields.get(name) || 0;
+                        if (true === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                        if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+                        else existingNonFields.set(name, true);
                     }
+                    applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
                 }
-                if (0 === kind || 1 === kind) {
-                    if (void 0 === init) init = function(instance, init) {
-                        return init;
+            }
+            pushInitializers(ret, protoInitializers);
+            pushInitializers(ret, staticInitializers);
+            return ret;
+        }
+        function pushInitializers(ret, initializers) {
+            if (initializers) ret.push(function(instance) {
+                for(var i = 0; i < initializers.length; i++)initializers[i].call(instance);
+                return instance;
+            });
+        }
+        function applyClassDecs(targetClass, classDecs, metadata) {
+            if (classDecs.length > 0) {
+                var initializers = [];
+                var newClass = targetClass;
+                var name = targetClass.name;
+                for(var i = classDecs.length - 1; i >= 0; i--){
+                    var decoratorFinishedRef = {
+                        v: false
                     };
-                    else if ("function" != typeof init) {
-                        var ownInitializers = init;
-                        init = function(instance, init) {
-                            var value = init;
-                            for(var i = 0; i < ownInitializers.length; i++)value = ownInitializers[i].call(instance, value);
-                            return value;
-                        };
-                    } else {
-                        var originalInitializer = init;
-                        init = function(instance, init) {
-                            return originalInitializer.call(instance, init);
-                        };
-                    }
-                    ret.push(init);
-                }
-                if (0 !== kind) {
-                    if (1 === kind) {
-                        desc.get = value.get;
-                        desc.set = value.set;
-                    } else if (2 === kind) desc.value = value;
-                    else if (3 === kind) desc.get = value;
-                    else if (4 === kind) desc.set = value;
-                    if (isPrivate) if (1 === kind) {
-                        ret.push(function(instance, args) {
-                            return value.get.call(instance, args);
+                    try {
+                        var nextNewClass = classDecs[i](newClass, {
+                            kind: "class",
+                            name: name,
+                            addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                            metadata
                         });
-                        ret.push(function(instance, args) {
-                            return value.set.call(instance, args);
-                        });
-                    } else if (2 === kind) ret.push(value);
-                    else ret.push(function(instance, args) {
-                        return value.call(instance, args);
-                    });
-                    else Object.defineProperty(base, name, desc);
-                }
-            }
-            function applyMemberDecs(Class, decInfos, metadata) {
-                var ret = [];
-                var protoInitializers;
-                var staticInitializers;
-                var existingProtoNonFields = new Map();
-                var existingStaticNonFields = new Map();
-                for(var i = 0; i < decInfos.length; i++){
-                    var decInfo = decInfos[i];
-                    if (Array.isArray(decInfo)) {
-                        var kind = decInfo[1];
-                        var name = decInfo[2];
-                        var isPrivate = decInfo.length > 3;
-                        var isStatic = kind >= 5;
-                        var base;
-                        var initializers;
-                        if (isStatic) {
-                            base = Class;
-                            kind -= 5;
-                            staticInitializers = staticInitializers || [];
-                            initializers = staticInitializers;
-                        } else {
-                            base = Class.prototype;
-                            protoInitializers = protoInitializers || [];
-                            initializers = protoInitializers;
-                        }
-                        if (0 !== kind && !isPrivate) {
-                            var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
-                            var existingKind = existingNonFields.get(name) || 0;
-                            if (true === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
-                            if (!existingKind && kind > 2) existingNonFields.set(name, kind);
-                            else existingNonFields.set(name, true);
-                        }
-                        applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+                    } finally{
+                        decoratorFinishedRef.v = true;
                     }
-                }
-                pushInitializers(ret, protoInitializers);
-                pushInitializers(ret, staticInitializers);
-                return ret;
-            }
-            function pushInitializers(ret, initializers) {
-                if (initializers) ret.push(function(instance) {
-                    for(var i = 0; i < initializers.length; i++)initializers[i].call(instance);
-                    return instance;
-                });
-            }
-            function applyClassDecs(targetClass, classDecs, metadata) {
-                if (classDecs.length > 0) {
-                    var initializers = [];
-                    var newClass = targetClass;
-                    var name = targetClass.name;
-                    for(var i = classDecs.length - 1; i >= 0; i--){
-                        var decoratorFinishedRef = {
-                            v: false
-                        };
-                        try {
-                            var nextNewClass = classDecs[i](newClass, {
-                                kind: "class",
-                                name: name,
-                                addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
-                                metadata
-                            });
-                        } finally{
-                            decoratorFinishedRef.v = true;
-                        }
-                        if (void 0 !== nextNewClass) {
-                            assertValidReturnValue(10, nextNewClass);
-                            newClass = nextNewClass;
-                        }
+                    if (void 0 !== nextNewClass) {
+                        assertValidReturnValue(10, nextNewClass);
+                        newClass = nextNewClass;
                     }
-                    return [
-                        defineMetadata(newClass, metadata),
-                        function() {
-                            for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
-                        }
-                    ];
                 }
-            }
-            function defineMetadata(Class, metadata) {
-                return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
-                    configurable: true,
-                    enumerable: true,
-                    value: metadata
-                });
-            }
-            return function(targetClass, memberDecs, classDecs, parentClass) {
-                if (void 0 !== parentClass) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
-                var metadata = Object.create(void 0 === parentMetadata ? null : parentMetadata);
-                var e = applyMemberDecs(targetClass, memberDecs, metadata);
-                if (!classDecs.length) defineMetadata(targetClass, metadata);
-                return {
-                    e: e,
-                    get c () {
-                        return applyClassDecs(targetClass, classDecs, metadata);
+                return [
+                    defineMetadata(newClass, metadata),
+                    function() {
+                        for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
                     }
-                };
-            };
-        }
-        function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
-            return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
-        }
-        var _dec, _dec1, _dec2, _dec3, _dec4, _dec5, _initProto;
-        const logger = (0, dist.zP)('Personalization');
-        _dec = (0, guardedBy.i)('hasConsent', {
-            onBlocked: 'onBlockedByConsent'
-        }), _dec1 = (0, guardedBy.i)('hasConsent', {
-            onBlocked: 'onBlockedByConsent'
-        }), _dec2 = (0, guardedBy.i)('hasConsent', {
-            onBlocked: 'onBlockedByConsent'
-        }), _dec3 = (0, guardedBy.i)('hasConsent', {
-            onBlocked: 'onBlockedByConsent'
-        }), _dec4 = (0, guardedBy.i)('isNotDuplicated', {
-            onBlocked: 'onBlockedByDuplication'
-        }), _dec5 = (0, guardedBy.i)('hasConsent', {
-            onBlocked: 'onBlockedByConsent'
-        });
-        class PersonalizationStateful extends personalization_PersonalizationBase {
-            static{
-                ({ e: [_initProto] } = _apply_decs_2203_r(this, [
-                    [
-                        _dec,
-                        2,
-                        "identify"
-                    ],
-                    [
-                        _dec1,
-                        2,
-                        "page"
-                    ],
-                    [
-                        _dec2,
-                        2,
-                        "screen"
-                    ],
-                    [
-                        _dec3,
-                        2,
-                        "track"
-                    ],
-                    [
-                        [
-                            _dec4,
-                            _dec5
-                        ],
-                        2,
-                        "trackComponentView"
-                    ]
-                ], []));
+                ];
             }
-            offlineQueue = (_initProto(this), new Set());
-            states = {
-                eventStream: (0, signals.br)(signals.f0),
-                flags: (0, signals.br)(signals.Mv),
-                profile: (0, signals.br)(signals.ME),
-                personalizations: (0, signals.br)(signals.wh)
-            };
-            getAnonymousId;
-            constructor(options){
-                const { api, builder, config, interceptors } = options;
-                super({
-                    api,
-                    builder,
-                    config,
-                    interceptors
-                });
-                const { defaults, getAnonymousId } = config ?? {};
-                if (defaults) {
-                    const { changes: defaultChanges, personalizations: defaultPersonalizations, profile: defaultProfile } = defaults;
-                    (0, signals.vA)(()=>{
-                        signals.Ao.value = defaultChanges;
-                        signals.wh.value = defaultPersonalizations;
-                        signals.ME.value = defaultProfile;
-                    });
+        }
+        function defineMetadata(Class, metadata) {
+            return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+                configurable: true,
+                enumerable: true,
+                value: metadata
+            });
+        }
+        return function(targetClass, memberDecs, classDecs, parentClass) {
+            if (void 0 !== parentClass) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+            var metadata = Object.create(void 0 === parentMetadata ? null : parentMetadata);
+            var e = applyMemberDecs(targetClass, memberDecs, metadata);
+            if (!classDecs.length) defineMetadata(targetClass, metadata);
+            return {
+                e: e,
+                get c () {
+                    return applyClassDecs(targetClass, classDecs, metadata);
                 }
-                if (defaults?.consent !== void 0) {
-                    const { consent: defaultConsent } = defaults;
-                    signals.vJ.value = defaultConsent;
+            };
+        };
+    }
+    function PersonalizationStateful_apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+        return (PersonalizationStateful_apply_decs_2203_r = PersonalizationStateful_applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+    }
+    var PersonalizationStateful_dec, PersonalizationStateful_dec1, PersonalizationStateful_dec2, PersonalizationStateful_dec3, _dec4, PersonalizationStateful_initProto;
+    const PersonalizationStateful_logger = (0, logger_namespaceObject.createScopedLogger)('Personalization');
+    const OFFLINE_QUEUE_MAX_EVENTS = 100;
+    const resolvePersonalizationQueuePolicy = (policy)=>({
+            maxEvents: toPositiveInt(policy?.maxEvents, OFFLINE_QUEUE_MAX_EVENTS),
+            onDrop: policy?.onDrop,
+            flushPolicy: resolveQueueFlushPolicy(policy?.flushPolicy)
+        });
+    PersonalizationStateful_dec = guardedBy('hasConsent', {
+        onBlocked: 'onBlockedByConsent'
+    }), PersonalizationStateful_dec1 = guardedBy('hasConsent', {
+        onBlocked: 'onBlockedByConsent'
+    }), PersonalizationStateful_dec2 = guardedBy('hasConsent', {
+        onBlocked: 'onBlockedByConsent'
+    }), PersonalizationStateful_dec3 = guardedBy('hasConsent', {
+        onBlocked: 'onBlockedByConsent'
+    }), _dec4 = guardedBy('hasConsent', {
+        onBlocked: 'onBlockedByConsent'
+    });
+    class PersonalizationStateful extends personalization_PersonalizationBase {
+        static{
+            ({ e: [PersonalizationStateful_initProto] } = PersonalizationStateful_apply_decs_2203_r(this, [
+                [
+                    PersonalizationStateful_dec,
+                    2,
+                    "identify"
+                ],
+                [
+                    PersonalizationStateful_dec1,
+                    2,
+                    "page"
+                ],
+                [
+                    PersonalizationStateful_dec2,
+                    2,
+                    "screen"
+                ],
+                [
+                    PersonalizationStateful_dec3,
+                    2,
+                    "track"
+                ],
+                [
+                    _dec4,
+                    2,
+                    "trackComponentView"
+                ]
+            ], []));
+        }
+        offlineQueue = (PersonalizationStateful_initProto(this), new Set());
+        queuePolicy;
+        flushRuntime;
+        states = {
+            blockedEventStream: toObservable(blockedEvent),
+            eventStream: toObservable(signals_event),
+            flags: toObservable(flags),
+            profile: toObservable(signals_profile),
+            personalizations: toObservable(signals_personalizations)
+        };
+        getAnonymousId;
+        constructor(options){
+            const { api, builder, config, interceptors } = options;
+            super({
+                api,
+                builder,
+                config,
+                interceptors
+            });
+            const { defaults, getAnonymousId, queuePolicy } = config ?? {};
+            this.queuePolicy = resolvePersonalizationQueuePolicy(queuePolicy);
+            this.flushRuntime = new QueueFlushRuntime({
+                policy: this.queuePolicy.flushPolicy,
+                onRetry: ()=>{
+                    this.flush();
+                },
+                onCallbackError: (callbackName, error)=>{
+                    PersonalizationStateful_logger.warn(`Personalization flush policy callback "${callbackName}" failed`, error);
                 }
-                this.getAnonymousId = getAnonymousId ?? (()=>void 0);
-                (0, signals.QZ)(()=>{
-                    logger.debug(`Profile ${signals.ME.value && `with ID ${signals.ME.value.id}`} has been ${signals.ME.value ? 'set' : 'cleared'}`);
-                });
-                (0, signals.QZ)(()=>{
-                    logger.debug(`Variants have been ${signals.wh.value?.length ? 'populated' : 'cleared'}`);
-                });
-                (0, signals.QZ)(()=>{
-                    logger.info(`Personalization ${signals.vJ.value ? 'will' : 'will not'} take effect due to consent (${signals.vJ.value})`);
-                });
-                (0, signals.QZ)(()=>{
-                    if (signals.WD.value) this.flush();
+            });
+            if (defaults) {
+                const { changes: defaultChanges, personalizations: defaultPersonalizations, profile: defaultProfile } = defaults;
+                (0, signals_core_namespaceObject.batch)(()=>{
+                    signals_changes.value = defaultChanges;
+                    signals_personalizations.value = defaultPersonalizations;
+                    signals_profile.value = defaultProfile;
                 });
             }
-            reset() {
-                (0, signals.vA)(()=>{
-                    signals.Ao.value = void 0;
-                    signals.f0.value = void 0;
-                    signals.ME.value = void 0;
-                    signals.wh.value = void 0;
+            if (defaults?.consent !== void 0) {
+                const { consent: defaultConsent } = defaults;
+                consent.value = defaultConsent;
+            }
+            this.getAnonymousId = getAnonymousId ?? (()=>void 0);
+            (0, signals_core_namespaceObject.effect)(()=>{
+                PersonalizationStateful_logger.debug(`Profile ${signals_profile.value && `with ID ${signals_profile.value.id}`} has been ${signals_profile.value ? 'set' : 'cleared'}`);
+            });
+            (0, signals_core_namespaceObject.effect)(()=>{
+                PersonalizationStateful_logger.debug(`Variants have been ${signals_personalizations.value?.length ? 'populated' : 'cleared'}`);
+            });
+            (0, signals_core_namespaceObject.effect)(()=>{
+                PersonalizationStateful_logger.info(`Personalization ${consent.value ? 'will' : 'will not'} take effect due to consent (${consent.value})`);
+            });
+            (0, signals_core_namespaceObject.effect)(()=>{
+                if (!online.value) return;
+                this.flushRuntime.clearScheduledRetry();
+                this.flush({
+                    force: true
                 });
-            }
-            getCustomFlag(name, changes = signals.Ao.value) {
-                return super.getCustomFlag(name, changes);
-            }
-            personalizeEntry(entry, personalizations = signals.wh.value) {
-                return super.personalizeEntry(entry, personalizations);
-            }
-            getMergeTagValue(embeddedEntryNodeTarget, profile = signals.ME.value) {
-                return super.getMergeTagValue(embeddedEntryNodeTarget, profile);
-            }
-            hasConsent(name) {
-                return !!signals.vJ.value || (this.allowedEventTypes ?? []).includes('trackComponentView' === name || 'trackFlagView' === name ? 'component' : name);
-            }
-            onBlockedByConsent(name, payload) {
-                logger.warn(`Event "${name}" was blocked due to lack of consent; payload: ${JSON.stringify(payload)}`);
-            }
-            isNotDuplicated(_name, payload) {
-                const [{ componentId: value }, duplicationScope] = payload;
-                const isDuplicated = this.duplicationDetector.isPresent(duplicationScope, value);
-                if (!isDuplicated) this.duplicationDetector.addValue(duplicationScope, value);
-                return !isDuplicated;
-            }
-            onBlockedByDuplication(_name, payload) {
-                logger.debug(`Duplicate "component view" event detected, skipping; payload: ${JSON.stringify(payload)}`);
-            }
-            async identify(payload) {
-                logger.info('Sending "identify" event');
-                const event = this.builder.buildIdentify(payload);
-                return await this.sendOrEnqueueEvent(event);
-            }
-            async page(payload) {
-                logger.info('Sending "page" event');
-                const event = this.builder.buildPageView(payload);
-                return await this.sendOrEnqueueEvent(event);
-            }
-            async screen(payload) {
-                logger.info(`Sending "screen" event for "${payload.name}"`);
-                const event = this.builder.buildScreenView(payload);
-                return await this.sendOrEnqueueEvent(event);
-            }
-            async track(payload) {
-                logger.info(`Sending "track" event "${payload.event}"`);
-                const event = this.builder.buildTrack(payload);
-                return await this.sendOrEnqueueEvent(event);
-            }
-            async trackComponentView(payload, _duplicationScope = '') {
-                logger.info(`Sending "track personalization" event for ${payload.componentId}`);
-                const event = this.builder.buildComponentView(payload);
-                return await this.sendOrEnqueueEvent(event);
-            }
-            async sendOrEnqueueEvent(event) {
-                const intercepted = await this.interceptors.event.run(event);
-                const validEvent = optimization_api_client_.ExperienceEvent.parse(intercepted);
-                signals.f0.value = validEvent;
-                if (signals.WD.value) return await this.upsertProfile([
-                    validEvent
-                ]);
-                logger.debug(`Queueing ${validEvent.type} event`, validEvent);
-                this.offlineQueue.add(validEvent);
-            }
-            async flush() {
-                if (0 === this.offlineQueue.size) return;
-                logger.debug('Flushing offline event queue');
-                await this.upsertProfile(Array.from(this.offlineQueue));
-                this.offlineQueue.clear();
-            }
-            async upsertProfile(events) {
-                const anonymousId = this.getAnonymousId();
-                if (anonymousId) logger.debug(`Anonymous ID found: ${anonymousId}`);
-                const data = await this.api.experience.upsertProfile({
-                    profileId: anonymousId ?? signals.ME.value?.id,
-                    events
-                });
-                await this.updateOutputSignals(data);
-                return data;
-            }
-            async updateOutputSignals(data) {
-                const intercepted = await this.interceptors.state.run(data);
-                const { changes, personalizations, profile } = intercepted;
-                (0, signals.vA)(()=>{
-                    if (!(0, external_es_toolkit_namespaceObject.isEqual)(signals.Ao.value, changes)) signals.Ao.value = changes;
-                    if (!(0, external_es_toolkit_namespaceObject.isEqual)(signals.ME.value, profile)) signals.ME.value = profile;
-                    if (!(0, external_es_toolkit_namespaceObject.isEqual)(signals.wh.value, personalizations)) signals.wh.value = personalizations;
-                });
-            }
+            });
         }
-        const personalization_PersonalizationStateful = PersonalizationStateful;
-        const PersonalizationStateless_logger = (0, dist.zP)('Personalization');
-        class PersonalizationStateless extends personalization_PersonalizationBase {
-            async identify(payload) {
-                PersonalizationStateless_logger.info('Sending "identify" event');
-                const { profile, ...builderArgs } = payload;
-                const event = optimization_api_client_.IdentifyEvent.parse(this.builder.buildIdentify(builderArgs));
-                return await this.upsertProfile(event, profile);
-            }
-            async page(payload) {
-                PersonalizationStateless_logger.info('Sending "page" event');
-                const { profile, ...builderArgs } = payload;
-                const event = optimization_api_client_.PageViewEvent.parse(this.builder.buildPageView(builderArgs));
-                return await this.upsertProfile(event, profile);
-            }
-            async screen(payload) {
-                PersonalizationStateless_logger.info(`Sending "screen" event for "${payload.name}"`);
-                const { profile, ...builderArgs } = payload;
-                const event = optimization_api_client_.ScreenViewEvent.parse(this.builder.buildScreenView(builderArgs));
-                return await this.upsertProfile(event, profile);
-            }
-            async track(payload) {
-                PersonalizationStateless_logger.info(`Sending "track" event "${payload.event}"`);
-                const { profile, ...builderArgs } = payload;
-                const event = optimization_api_client_.TrackEvent.parse(this.builder.buildTrack(builderArgs));
-                return await this.upsertProfile(event, profile);
-            }
-            async trackComponentView(payload) {
-                PersonalizationStateless_logger.info('Sending "track personalization" event');
-                const { profile, ...builderArgs } = payload;
-                const event = optimization_api_client_.ComponentViewEvent.parse(this.builder.buildComponentView(builderArgs));
-                return await this.upsertProfile(event, profile);
+        reset() {
+            this.flushRuntime.reset();
+            (0, signals_core_namespaceObject.batch)(()=>{
+                signals_changes.value = void 0;
+                blockedEvent.value = void 0;
+                signals_event.value = void 0;
+                signals_profile.value = void 0;
+                signals_personalizations.value = void 0;
+            });
+        }
+        getCustomFlag(name, changes = signals_changes.value) {
+            return super.getCustomFlag(name, changes);
+        }
+        getCustomFlags(changes = signals_changes.value) {
+            return super.getCustomFlags(changes);
+        }
+        personalizeEntry(entry, personalizations = signals_personalizations.value) {
+            return super.personalizeEntry(entry, personalizations);
+        }
+        getMergeTagValue(embeddedEntryNodeTarget, profile = signals_profile.value) {
+            return super.getMergeTagValue(embeddedEntryNodeTarget, profile);
+        }
+        hasConsent(name) {
+            return !!consent.value || (this.allowedEventTypes ?? []).includes('trackComponentView' === name || 'trackFlagView' === name ? 'component' : name);
+        }
+        onBlockedByConsent(name, payload) {
+            PersonalizationStateful_logger.warn(`Event "${name}" was blocked due to lack of consent; payload: ${JSON.stringify(payload)}`);
+            this.reportBlockedEvent('consent', 'personalization', name, payload);
+        }
+        async identify(payload) {
+            PersonalizationStateful_logger.info('Sending "identify" event');
+            const event = this.builder.buildIdentify(payload);
+            return await this.sendOrEnqueueEvent(event);
+        }
+        async page(payload) {
+            PersonalizationStateful_logger.info('Sending "page" event');
+            const event = this.builder.buildPageView(payload);
+            return await this.sendOrEnqueueEvent(event);
+        }
+        async screen(payload) {
+            PersonalizationStateful_logger.info(`Sending "screen" event for "${payload.name}"`);
+            const event = this.builder.buildScreenView(payload);
+            return await this.sendOrEnqueueEvent(event);
+        }
+        async track(payload) {
+            PersonalizationStateful_logger.info(`Sending "track" event "${payload.event}"`);
+            const event = this.builder.buildTrack(payload);
+            return await this.sendOrEnqueueEvent(event);
+        }
+        async trackComponentView(payload) {
+            PersonalizationStateful_logger.info(`Sending "track personalization" event for ${payload.componentId}`);
+            const event = this.builder.buildComponentView(payload);
+            return await this.sendOrEnqueueEvent(event);
+        }
+        async sendOrEnqueueEvent(event) {
+            const intercepted = await this.interceptors.event.run(event);
+            const validEvent = (0, api_schemas_namespaceObject.parseWithFriendlyError)(api_schemas_namespaceObject.ExperienceEvent, intercepted);
+            signals_event.value = validEvent;
+            if (online.value) return await this.upsertProfile([
+                validEvent
+            ]);
+            PersonalizationStateful_logger.debug(`Queueing ${validEvent.type} event`, validEvent);
+            this.enqueueOfflineEvent(validEvent);
+        }
+        enqueueOfflineEvent(event) {
+            let droppedEvents = [];
+            if (this.offlineQueue.size >= this.queuePolicy.maxEvents) {
+                const dropCount = this.offlineQueue.size - this.queuePolicy.maxEvents + 1;
+                droppedEvents = this.dropOldestOfflineEvents(dropCount);
+                if (droppedEvents.length > 0) PersonalizationStateful_logger.warn(`Dropped ${droppedEvents.length} oldest personalization offline event(s) due to queue limit (${this.queuePolicy.maxEvents})`);
+            }
+            this.offlineQueue.add(event);
+            if (droppedEvents.length > 0) this.invokeQueueDropCallback({
+                droppedCount: droppedEvents.length,
+                droppedEvents,
+                maxEvents: this.queuePolicy.maxEvents,
+                queuedEvents: this.offlineQueue.size
+            });
+        }
+        dropOldestOfflineEvents(count) {
+            const droppedEvents = [];
+            for(let index = 0; index < count; index += 1){
+                const oldestEvent = this.offlineQueue.values().next();
+                if (oldestEvent.done) break;
+                this.offlineQueue.delete(oldestEvent.value);
+                droppedEvents.push(oldestEvent.value);
+            }
+            return droppedEvents;
+        }
+        invokeQueueDropCallback(context) {
+            try {
+                this.queuePolicy.onDrop?.(context);
+            } catch (error) {
+                PersonalizationStateful_logger.warn('Personalization offline queue drop callback failed', error);
             }
-            async upsertProfile(event, profile) {
-                const intercepted = await this.interceptors.event.run(event);
-                const data = await this.api.experience.upsertProfile({
-                    profileId: profile?.id,
-                    events: [
-                        intercepted
-                    ]
+        }
+        async flush(options = {}) {
+            await this.flushOfflineQueue(options);
+        }
+        async flushOfflineQueue(options = {}) {
+            const { force = false } = options;
+            if (this.flushRuntime.shouldSkip({
+                force,
+                isOnline: !!online.value
+            })) return;
+            if (0 === this.offlineQueue.size) return void this.flushRuntime.clearScheduledRetry();
+            PersonalizationStateful_logger.debug('Flushing offline event queue');
+            const queuedEvents = Array.from(this.offlineQueue);
+            this.flushRuntime.markFlushStarted();
+            try {
+                const sendSuccess = await this.tryUpsertQueuedEvents(queuedEvents);
+                if (sendSuccess) {
+                    queuedEvents.forEach((event)=>{
+                        this.offlineQueue.delete(event);
+                    });
+                    this.flushRuntime.handleFlushSuccess();
+                } else this.flushRuntime.handleFlushFailure({
+                    queuedBatches: this.offlineQueue.size > 0 ? 1 : 0,
+                    queuedEvents: this.offlineQueue.size
                 });
-                return data;
+            } finally{
+                this.flushRuntime.markFlushFinished();
             }
         }
-        const personalization_PersonalizationStateless = PersonalizationStateless;
-    },
-    "./src/personalization/resolvers/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            OR: ()=>resolvers_FlagsResolver,
-            cv: ()=>resolvers_MergeTagValueResolver,
-            z8: ()=>resolvers_PersonalizedEntryResolver
-        });
-        const FlagsResolver = {
-            resolve (changes) {
-                if (!changes) return {};
-                return changes.reduce((acc, { key, value })=>{
-                    const actualValue = 'object' == typeof value && null !== value && 'value' in value && 'object' == typeof value.value ? value.value : value;
-                    acc[key] = actualValue;
-                    return acc;
-                }, {});
-            }
-        };
-        const resolvers_FlagsResolver = FlagsResolver;
-        var optimization_api_client_ = __webpack_require__("@contentful/optimization-api-client");
-        const compat_namespaceObject = require("es-toolkit/compat");
-        var dist = __webpack_require__("../../lib/logger/dist/index.mjs");
-        const logger = (0, dist.zP)('Personalization');
-        const RESOLUTION_WARNING_BASE = 'Could not resolve Merge Tag value:';
-        const MergeTagValueResolver = {
-            isMergeTagEntry (embeddedEntryNodeTarget) {
-                return optimization_api_client_.MergeTagEntry.safeParse(embeddedEntryNodeTarget).success;
-            },
-            normalizeSelectors (id) {
-                return id.split('_').map((_path, index, paths)=>{
-                    const dotPath = paths.slice(0, index).join('.');
-                    const underScorePath = paths.slice(index).join('_');
-                    return [
-                        dotPath,
-                        underScorePath
-                    ].filter((path)=>'' !== path).join('.');
-                });
-            },
-            getValueFromProfile (id, profile) {
-                const selectors = MergeTagValueResolver.normalizeSelectors(id);
-                const matchingSelector = selectors.find((selector)=>(0, compat_namespaceObject.get)(profile, selector));
-                if (!matchingSelector) return;
-                const value = (0, compat_namespaceObject.get)(profile, matchingSelector);
-                if (!value || 'string' != typeof value && 'number' != typeof value && 'boolean' != typeof value) return;
-                return `${value}`;
-            },
-            resolve (mergeTagEntry, profile) {
-                if (!MergeTagValueResolver.isMergeTagEntry(mergeTagEntry)) return void logger.warn(`${RESOLUTION_WARNING_BASE} supplied entry is not a Merge Tag entry`);
-                const { fields: { nt_fallback: fallback } } = mergeTagEntry;
-                if (!optimization_api_client_.Profile.safeParse(profile).success) {
-                    logger.warn(`${RESOLUTION_WARNING_BASE} no valid profile`);
-                    return fallback;
-                }
-                return MergeTagValueResolver.getValueFromProfile(mergeTagEntry.fields.nt_mergetag_id, profile) ?? fallback;
+        async tryUpsertQueuedEvents(events) {
+            try {
+                await this.upsertProfile(events);
+                return true;
+            } catch (error) {
+                PersonalizationStateful_logger.warn('Personalization offline queue flush request threw an error', error);
+                return false;
             }
+        }
+        async upsertProfile(events) {
+            const anonymousId = this.getAnonymousId();
+            if (anonymousId) PersonalizationStateful_logger.debug(`Anonymous ID found: ${anonymousId}`);
+            const data = await this.api.experience.upsertProfile({
+                profileId: anonymousId ?? signals_profile.value?.id,
+                events
+            });
+            await this.updateOutputSignals(data);
+            return data;
+        }
+        async updateOutputSignals(data) {
+            const intercepted = await this.interceptors.state.run(data);
+            const { changes, personalizations, profile } = intercepted;
+            (0, signals_core_namespaceObject.batch)(()=>{
+                if (!(0, predicate_namespaceObject.isEqual)(signals_changes.value, changes)) signals_changes.value = changes;
+                if (!(0, predicate_namespaceObject.isEqual)(signals_profile.value, profile)) signals_profile.value = profile;
+                if (!(0, predicate_namespaceObject.isEqual)(signals_personalizations.value, personalizations)) signals_personalizations.value = personalizations;
+            });
+        }
+    }
+    const personalization_PersonalizationStateful = PersonalizationStateful;
+    const PersonalizationStateless_logger = (0, logger_namespaceObject.createScopedLogger)('Personalization');
+    class PersonalizationStateless extends personalization_PersonalizationBase {
+        async identify(payload) {
+            PersonalizationStateless_logger.info('Sending "identify" event');
+            const { profile, ...builderArgs } = payload;
+            const event = (0, api_schemas_namespaceObject.parseWithFriendlyError)(api_schemas_namespaceObject.IdentifyEvent, this.builder.buildIdentify(builderArgs));
+            return await this.upsertProfile(event, profile);
+        }
+        async page(payload) {
+            PersonalizationStateless_logger.info('Sending "page" event');
+            const { profile, ...builderArgs } = payload;
+            const event = (0, api_schemas_namespaceObject.parseWithFriendlyError)(api_schemas_namespaceObject.PageViewEvent, this.builder.buildPageView(builderArgs));
+            return await this.upsertProfile(event, profile);
+        }
+        async screen(payload) {
+            PersonalizationStateless_logger.info(`Sending "screen" event for "${payload.name}"`);
+            const { profile, ...builderArgs } = payload;
+            const event = (0, api_schemas_namespaceObject.parseWithFriendlyError)(api_schemas_namespaceObject.ScreenViewEvent, this.builder.buildScreenView(builderArgs));
+            return await this.upsertProfile(event, profile);
+        }
+        async track(payload) {
+            PersonalizationStateless_logger.info(`Sending "track" event "${payload.event}"`);
+            const { profile, ...builderArgs } = payload;
+            const event = (0, api_schemas_namespaceObject.parseWithFriendlyError)(api_schemas_namespaceObject.TrackEvent, this.builder.buildTrack(builderArgs));
+            return await this.upsertProfile(event, profile);
+        }
+        async trackComponentView(payload) {
+            PersonalizationStateless_logger.info('Sending "track personalization" event');
+            const { profile, ...builderArgs } = payload;
+            const event = (0, api_schemas_namespaceObject.parseWithFriendlyError)(api_schemas_namespaceObject.ComponentViewEvent, this.builder.buildComponentView(builderArgs));
+            return await this.upsertProfile(event, profile);
+        }
+        async upsertProfile(event, profile) {
+            const intercepted = await this.interceptors.event.run(event);
+            const validEvent = (0, api_schemas_namespaceObject.parseWithFriendlyError)(api_schemas_namespaceObject.ExperienceEvent, intercepted);
+            const data = await this.api.experience.upsertProfile({
+                profileId: profile?.id,
+                events: [
+                    validEvent
+                ]
+            });
+            return data;
+        }
+    }
+    const personalization_PersonalizationStateless = PersonalizationStateless;
+    var symbols = __webpack_require__("./src/symbols.ts");
+    const splitScopedQueuePolicy = (config)=>{
+        if (void 0 === config) return {
+            apiConfig: void 0,
+            queuePolicy: void 0
         };
-        const resolvers_MergeTagValueResolver = MergeTagValueResolver;
-        const PersonalizedEntryResolver_logger = (0, dist.zP)('Personalization');
-        const PersonalizedEntryResolver_RESOLUTION_WARNING_BASE = 'Could not resolve personalized entry variant:';
-        const PersonalizedEntryResolver = {
-            getPersonalizationEntry ({ personalizedEntry, selectedPersonalizations }, skipValidation = false) {
-                if (!skipValidation && (!selectedPersonalizations.length || !(0, optimization_api_client_.isPersonalizedEntry)(personalizedEntry))) return;
-                const personalizationEntry = personalizedEntry.fields.nt_experiences.filter((maybePersonalization)=>(0, optimization_api_client_.isPersonalizationEntry)(maybePersonalization)).find((personalizationEntry)=>selectedPersonalizations.some(({ experienceId })=>experienceId === personalizationEntry.fields.nt_experience_id));
-                return personalizationEntry;
-            },
-            getSelectedPersonalization ({ personalizationEntry, selectedPersonalizations }, skipValidation = false) {
-                if (!skipValidation && (!selectedPersonalizations.length || !(0, optimization_api_client_.isPersonalizationEntry)(personalizationEntry))) return;
-                const selectedPersonalization = selectedPersonalizations.find(({ experienceId })=>experienceId === personalizationEntry.fields.nt_experience_id);
-                return selectedPersonalization;
-            },
-            getSelectedVariant ({ personalizedEntry, personalizationEntry, selectedVariantIndex }, skipValidation = false) {
-                if (!skipValidation && (!(0, optimization_api_client_.isPersonalizedEntry)(personalizedEntry) || !(0, optimization_api_client_.isPersonalizationEntry)(personalizationEntry))) return;
-                const relevantVariants = personalizationEntry.fields.nt_config?.components?.filter((component)=>(0, optimization_api_client_.isEntryReplacementComponent)(component) && !component.baseline.hidden).find((component)=>component.baseline.id === personalizedEntry.sys.id)?.variants;
-                if (!relevantVariants?.length) return;
-                return relevantVariants.at(selectedVariantIndex - 1);
-            },
-            getSelectedVariantEntry ({ personalizationEntry, selectedVariant }, skipValidation = false) {
-                if (!skipValidation && (!(0, optimization_api_client_.isPersonalizationEntry)(personalizationEntry) || !(0, optimization_api_client_.isEntryReplacementVariant)(selectedVariant))) return;
-                const selectedVariantEntry = personalizationEntry.fields.nt_variants?.find((variant)=>variant.sys.id === selectedVariant.id);
-                return (0, optimization_api_client_.isEntry)(selectedVariantEntry) ? selectedVariantEntry : void 0;
-            },
-            resolve (entry, selectedPersonalizations) {
-                PersonalizedEntryResolver_logger.debug(`Resolving personalized entry for baseline entry ${entry.sys.id}`);
-                if (!selectedPersonalizations?.length) {
-                    PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} no selectedPersonalizations exist for the current profile`);
-                    return {
-                        entry
-                    };
-                }
-                if (!(0, optimization_api_client_.isPersonalizedEntry)(entry)) {
-                    PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} entry ${entry.sys.id} is not personalized`);
-                    return {
-                        entry
-                    };
-                }
-                const personalizationEntry = PersonalizedEntryResolver.getPersonalizationEntry({
-                    personalizedEntry: entry,
-                    selectedPersonalizations
-                }, true);
-                if (!personalizationEntry) {
-                    PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a personalization entry for ${entry.sys.id}`);
-                    return {
-                        entry
-                    };
-                }
-                const selectedPersonalization = PersonalizedEntryResolver.getSelectedPersonalization({
-                    personalizationEntry,
-                    selectedPersonalizations
-                }, true);
-                const selectedVariantIndex = selectedPersonalization?.variantIndex ?? 0;
-                if (0 === selectedVariantIndex) {
-                    PersonalizedEntryResolver_logger.debug(`Resolved personalization entry for entry ${entry.sys.id} is baseline`);
-                    return {
-                        entry
-                    };
-                }
-                const selectedVariant = PersonalizedEntryResolver.getSelectedVariant({
-                    personalizedEntry: entry,
-                    personalizationEntry,
-                    selectedVariantIndex
-                }, true);
-                if (!selectedVariant) {
-                    PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a valid replacement variant entry for ${entry.sys.id}`);
-                    return {
-                        entry
-                    };
-                }
-                const selectedVariantEntry = PersonalizedEntryResolver.getSelectedVariantEntry({
-                    personalizationEntry,
-                    selectedVariant
-                }, true);
-                if (selectedVariantEntry) PersonalizedEntryResolver_logger.debug(`Entry ${entry.sys.id} has been resolved to variant entry ${selectedVariantEntry.sys.id}`);
-                else {
-                    PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a valid replacement variant entry for ${entry.sys.id}`);
-                    return {
-                        entry
-                    };
-                }
-                return {
-                    entry: selectedVariantEntry,
-                    personalization: selectedPersonalization
-                };
-            }
+        const { queuePolicy, ...apiConfig } = config;
+        const resolvedApiConfig = Object.keys(apiConfig).length > 0 ? apiConfig : void 0;
+        return {
+            apiConfig: resolvedApiConfig,
+            queuePolicy
         };
-        const resolvers_PersonalizedEntryResolver = PersonalizedEntryResolver;
-    },
-    "./src/signals.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            WD: ()=>online,
-            vA: ()=>signals_core_namespaceObject.batch,
-            ME: ()=>profile,
-            f0: ()=>signals_event,
-            QO: ()=>signals,
-            Mv: ()=>flags,
-            br: ()=>toObservable,
-            vJ: ()=>consent,
-            Ao: ()=>changes,
-            QZ: ()=>signals_core_namespaceObject.effect,
-            wh: ()=>personalizations
-        });
-        const signals_core_namespaceObject = require("@preact/signals-core");
-        var resolvers = __webpack_require__("./src/personalization/resolvers/index.ts");
-        const changes = (0, signals_core_namespaceObject.signal)();
-        const consent = (0, signals_core_namespaceObject.signal)();
-        const signals_event = (0, signals_core_namespaceObject.signal)();
-        const flags = (0, signals_core_namespaceObject.computed)(()=>resolvers.OR.resolve(changes.value ?? []));
-        const online = (0, signals_core_namespaceObject.signal)(true);
-        const personalizations = (0, signals_core_namespaceObject.signal)();
-        const profile = (0, signals_core_namespaceObject.signal)();
-        function toObservable(s) {
-            return {
-                subscribe (next) {
-                    const dispose = (0, signals_core_namespaceObject.effect)(()=>{
-                        next(s.value);
-                    });
-                    return {
-                        unsubscribe: dispose
-                    };
-                }
+    };
+    let statefulInstanceCounter = 0;
+    class CoreStateful extends src_CoreBase {
+        singletonOwner;
+        destroyed = false;
+        _analytics;
+        _personalization;
+        constructor(config){
+            const { apiConfig: analyticsApiConfig, queuePolicy: analyticsRuntimeQueuePolicy } = splitScopedQueuePolicy(config.analytics);
+            const { apiConfig: personalizationApiConfig, queuePolicy: personalizationRuntimeQueuePolicy } = splitScopedQueuePolicy(config.personalization);
+            const baseConfig = {
+                ...config,
+                analytics: analyticsApiConfig,
+                personalization: personalizationApiConfig
             };
-        }
-        const signals = {
-            changes,
-            consent,
-            event: signals_event,
-            flags,
-            online,
-            personalizations,
-            profile
-        };
-    },
-    "@contentful/optimization-api-client" (module) {
-        module.exports = require("@contentful/optimization-api-client");
-    },
-    "../../lib/logger/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            Vy: ()=>Logger,
-            vF: ()=>logger,
-            zP: ()=>createScopedLogger,
-            vg: ()=>ConsoleLogSink,
-            y$: ()=>src_LogSink
-        });
-        const external_diary_namespaceObject = require("diary");
-        const utils_namespaceObject = require("diary/utils");
-        class Logger {
-            name = '@contentful/optimization';
-            PREFIX_PARTS = [
-                'Ctfl',
-                'O10n'
-            ];
-            DELIMITER = ':';
-            diary;
-            sinks = [];
-            constructor(){
-                this.diary = (0, external_diary_namespaceObject.diary)(this.name, this.onLogEvent.bind(this));
-                (0, external_diary_namespaceObject.enable)(this.name);
-            }
-            assembleLocationPrefix(logLocation) {
-                return `[${[
-                    ...this.PREFIX_PARTS,
-                    logLocation
-                ].join(this.DELIMITER)}]`;
-            }
-            addSink(sink) {
-                this.sinks = [
-                    ...this.sinks.filter((existingSink)=>existingSink.name !== sink.name),
-                    sink
-                ];
-            }
-            removeSink(name) {
-                this.sinks = this.sinks.filter((sink)=>sink.name !== name);
-            }
-            removeSinks() {
-                this.sinks = [];
-            }
-            debug(logLocation, message, ...args) {
-                this.diary.debug(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-            }
-            info(logLocation, message, ...args) {
-                this.diary.info(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-            }
-            log(logLocation, message, ...args) {
-                this.diary.log(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-            }
-            warn(logLocation, message, ...args) {
-                this.diary.warn(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-            }
-            error(logLocation, message, ...args) {
-                this.diary.error(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-            }
-            fatal(logLocation, message, ...args) {
-                this.diary.fatal(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-            }
-            onLogEvent(event) {
-                this.sinks.forEach((sink)=>{
-                    sink.ingest(event);
+            super(baseConfig);
+            this.singletonOwner = `CoreStateful#${++statefulInstanceCounter}`;
+            acquireStatefulRuntimeSingleton(this.singletonOwner);
+            try {
+                const { allowedEventTypes, defaults, getAnonymousId, onEventBlocked } = config;
+                if (defaults?.consent !== void 0) {
+                    const { consent: defaultConsent } = defaults;
+                    consent.value = defaultConsent;
+                }
+                this._analytics = new analytics_AnalyticsStateful({
+                    api: this.api,
+                    builder: this.eventBuilder,
+                    config: {
+                        allowedEventTypes,
+                        queuePolicy: analyticsRuntimeQueuePolicy,
+                        onEventBlocked,
+                        defaults: {
+                            consent: defaults?.consent,
+                            profile: defaults?.profile
+                        }
+                    },
+                    interceptors: this.interceptors
+                });
+                this._personalization = new personalization_PersonalizationStateful({
+                    api: this.api,
+                    builder: this.eventBuilder,
+                    config: {
+                        allowedEventTypes,
+                        getAnonymousId,
+                        queuePolicy: personalizationRuntimeQueuePolicy,
+                        onEventBlocked,
+                        defaults: {
+                            consent: defaults?.consent,
+                            changes: defaults?.changes,
+                            profile: defaults?.profile,
+                            personalizations: defaults?.personalizations
+                        }
+                    },
+                    interceptors: this.interceptors
                 });
+            } catch (error) {
+                releaseStatefulRuntimeSingleton(this.singletonOwner);
+                throw error;
             }
         }
-        const logger = new Logger();
-        function createScopedLogger(location) {
+        destroy() {
+            if (this.destroyed) return;
+            this.destroyed = true;
+            releaseStatefulRuntimeSingleton(this.singletonOwner);
+        }
+        get states() {
             return {
-                debug: (message, ...args)=>{
-                    logger.debug(location, message, ...args);
-                },
-                info: (message, ...args)=>{
-                    logger.info(location, message, ...args);
-                },
-                log: (message, ...args)=>{
-                    logger.log(location, message, ...args);
-                },
-                warn: (message, ...args)=>{
-                    logger.warn(location, message, ...args);
-                },
-                error: (message, ...args)=>{
-                    logger.error(location, message, ...args);
-                },
-                fatal: (message, ...args)=>{
-                    logger.fatal(location, message, ...args);
-                }
+                blockedEventStream: toObservable(blockedEvent),
+                consent: toObservable(consent),
+                eventStream: toObservable(signals_event),
+                flags: toObservable(flags),
+                personalizations: toObservable(signals_personalizations),
+                previewPanelAttached: toObservable(previewPanelAttached),
+                previewPanelOpen: toObservable(previewPanelOpen),
+                profile: toObservable(signals_profile)
             };
         }
-        class LogSink {
-        }
-        const src_LogSink = LogSink;
-        const consoleMap = {
-            debug: (...args)=>{
-                console.debug(...args);
-            },
-            info: (...args)=>{
-                console.info(...args);
-            },
-            log: (...args)=>{
-                console.log(...args);
-            },
-            warn: (...args)=>{
-                console.warn(...args);
-            },
-            error: (...args)=>{
-                console.error(...args);
-            },
-            fatal: (...args)=>{
-                console.error(...args);
-            }
-        };
-        const COMPARISON_EQUALITY = 0;
-        class ConsoleLogSink extends src_LogSink {
-            name = 'ConsoleLogSink';
-            verbosity;
-            constructor(verbosity){
-                super();
-                this.verbosity = verbosity ?? 'error';
-            }
-            ingest(event) {
-                if ((0, utils_namespaceObject.compare)(this.verbosity, event.level) > COMPARISON_EQUALITY) return;
-                consoleMap[event.level](...event.messages);
-            }
+        reset() {
+            (0, signals_core_namespaceObject.batch)(()=>{
+                blockedEvent.value = void 0;
+                signals_event.value = void 0;
+                signals_changes.value = void 0;
+                signals_profile.value = void 0;
+                signals_personalizations.value = void 0;
+            });
+        }
+        async flush() {
+            await this._analytics.flush();
+            await this._personalization.flush();
+        }
+        consent(accept) {
+            consent.value = accept;
+        }
+        get online() {
+            return online.value ?? false;
+        }
+        set online(isOnline) {
+            online.value = isOnline;
+        }
+        registerPreviewPanel(previewPanel) {
+            Reflect.set(previewPanel, symbols.PREVIEW_PANEL_SIGNALS_SYMBOL, signals);
+            Reflect.set(previewPanel, symbols.PREVIEW_PANEL_SIGNAL_FNS_SYMBOL, signalFns);
         }
     }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        ANONYMOUS_ID_COOKIE: ()=>_global_constants__rspack_import_7.T,
-        AnalyticsStateful: ()=>_analytics__rspack_import_3.R,
-        AnalyticsStateless: ()=>_analytics__rspack_import_3.v,
-        ConsoleLogSink: ()=>logger__rspack_import_2.vg,
-        CoreStateful: ()=>_CoreStateful__rspack_import_5.A,
-        CoreStateless: ()=>_CoreStateless__rspack_import_6.A,
-        FlagsResolver: ()=>_personalization__rspack_import_11.OR,
-        InterceptorManager: ()=>_lib_interceptor__rspack_import_9.v,
-        LogSink: ()=>logger__rspack_import_2.y$,
-        Logger: ()=>logger__rspack_import_2.Vy,
-        MergeTagValueResolver: ()=>_personalization__rspack_import_11.cv,
-        OPTIMIZATION_CORE_SDK_VERSION: ()=>_global_constants__rspack_import_7.E,
-        PersonalizationStateful: ()=>_personalization__rspack_import_11.$C,
-        PersonalizationStateless: ()=>_personalization__rspack_import_11.jL,
-        PersonalizedEntryResolver: ()=>_personalization__rspack_import_11.z8,
-        ValuePresence: ()=>_lib_value_presence__rspack_import_10.n,
-        batch: ()=>_signals__rspack_import_0.vA,
-        createScopedLogger: ()=>logger__rspack_import_2.zP,
-        effect: ()=>_signals__rspack_import_0.QZ,
-        guardedBy: ()=>_lib_decorators__rspack_import_8.i,
-        logger: ()=>logger__rspack_import_2.vF,
-        signals: ()=>_signals__rspack_import_0.QO
-    });
-    var _signals__rspack_import_0 = __webpack_require__("./src/signals.ts");
-    var _contentful_optimization_api_client__rspack_import_1 = __webpack_require__("@contentful/optimization-api-client");
-    var __rspack_reexport = {};
-    for(const __rspack_import_key in _contentful_optimization_api_client__rspack_import_1)if ([
-        "CoreStateless",
-        "signals",
-        "CoreStateful",
-        "default",
-        "batch",
-        "effect"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_contentful_optimization_api_client__rspack_import_1[__rspack_import_key];
-    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var logger__rspack_import_2 = __webpack_require__("../../lib/logger/dist/index.mjs");
-    var _analytics__rspack_import_3 = __webpack_require__("./src/analytics/index.ts");
-    __webpack_require__("./src/CoreBase.ts");
-    var _CoreStateful__rspack_import_5 = __webpack_require__("./src/CoreStateful.ts");
-    var _CoreStateless__rspack_import_6 = __webpack_require__("./src/CoreStateless.ts");
-    var _global_constants__rspack_import_7 = __webpack_require__("./src/global-constants.ts");
-    var _lib_decorators__rspack_import_8 = __webpack_require__("./src/lib/decorators/index.ts");
-    var _lib_interceptor__rspack_import_9 = __webpack_require__("./src/lib/interceptor/index.ts");
-    var _lib_value_presence__rspack_import_10 = __webpack_require__("./src/lib/value-presence/index.ts");
-    var _personalization__rspack_import_11 = __webpack_require__("./src/personalization/index.ts");
+    const src_CoreStateful = CoreStateful;
+    class CoreStateless extends src_CoreBase {
+        _analytics;
+        _personalization;
+        constructor(config){
+            super(config);
+            this._analytics = new analytics_AnalyticsStateless({
+                api: this.api,
+                builder: this.eventBuilder,
+                interceptors: this.interceptors
+            });
+            this._personalization = new personalization_PersonalizationStateless({
+                api: this.api,
+                builder: this.eventBuilder,
+                interceptors: this.interceptors
+            });
+        }
+    }
+    const src_CoreStateless = CoreStateless;
 })();
 exports.ANONYMOUS_ID_COOKIE = __webpack_exports__.ANONYMOUS_ID_COOKIE;
+exports.ANONYMOUS_ID_COOKIE_LEGACY = __webpack_exports__.ANONYMOUS_ID_COOKIE_LEGACY;
+exports.ANONYMOUS_ID_KEY = __webpack_exports__.ANONYMOUS_ID_KEY;
+exports.ANONYMOUS_ID_KEY_LEGACY = __webpack_exports__.ANONYMOUS_ID_KEY_LEGACY;
 exports.AnalyticsStateful = __webpack_exports__.AnalyticsStateful;
 exports.AnalyticsStateless = __webpack_exports__.AnalyticsStateless;
-exports.ConsoleLogSink = __webpack_exports__.ConsoleLogSink;
+exports.CHANGES_CACHE_KEY = __webpack_exports__.CHANGES_CACHE_KEY;
+exports.CONSENT_KEY = __webpack_exports__.CONSENT_KEY;
 exports.CoreStateful = __webpack_exports__.CoreStateful;
 exports.CoreStateless = __webpack_exports__.CoreStateless;
+exports.DEBUG_FLAG_KEY = __webpack_exports__.DEBUG_FLAG_KEY;
 exports.FlagsResolver = __webpack_exports__.FlagsResolver;
 exports.InterceptorManager = __webpack_exports__.InterceptorManager;
-exports.LogSink = __webpack_exports__.LogSink;
-exports.Logger = __webpack_exports__.Logger;
 exports.MergeTagValueResolver = __webpack_exports__.MergeTagValueResolver;
+exports.OPTIMIZATION_CORE_SDK_NAME = __webpack_exports__.OPTIMIZATION_CORE_SDK_NAME;
 exports.OPTIMIZATION_CORE_SDK_VERSION = __webpack_exports__.OPTIMIZATION_CORE_SDK_VERSION;
+exports.PERSONALIZATIONS_CACHE_KEY = __webpack_exports__.PERSONALIZATIONS_CACHE_KEY;
+exports.PREVIEW_PANEL_SIGNALS_SYMBOL = __webpack_exports__.PREVIEW_PANEL_SIGNALS_SYMBOL;
+exports.PREVIEW_PANEL_SIGNAL_FNS_SYMBOL = __webpack_exports__.PREVIEW_PANEL_SIGNAL_FNS_SYMBOL;
+exports.PROFILE_CACHE_KEY = __webpack_exports__.PROFILE_CACHE_KEY;
+exports.PersonalizationBase = __webpack_exports__.PersonalizationBase;
 exports.PersonalizationStateful = __webpack_exports__.PersonalizationStateful;
 exports.PersonalizationStateless = __webpack_exports__.PersonalizationStateless;
 exports.PersonalizedEntryResolver = __webpack_exports__.PersonalizedEntryResolver;
-exports.ValuePresence = __webpack_exports__.ValuePresence;
 exports.batch = __webpack_exports__.batch;
-exports.createScopedLogger = __webpack_exports__.createScopedLogger;
 exports.effect = __webpack_exports__.effect;
 exports.guardedBy = __webpack_exports__.guardedBy;
-exports.logger = __webpack_exports__.logger;
+exports.signalFns = __webpack_exports__.signalFns;
 exports.signals = __webpack_exports__.signals;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ANONYMOUS_ID_COOKIE",
+    "ANONYMOUS_ID_COOKIE_LEGACY",
+    "ANONYMOUS_ID_KEY",
+    "ANONYMOUS_ID_KEY_LEGACY",
     "AnalyticsStateful",
     "AnalyticsStateless",
-    "ConsoleLogSink",
+    "CHANGES_CACHE_KEY",
+    "CONSENT_KEY",
     "CoreStateful",
     "CoreStateless",
+    "DEBUG_FLAG_KEY",
     "FlagsResolver",
     "InterceptorManager",
-    "LogSink",
-    "Logger",
     "MergeTagValueResolver",
+    "OPTIMIZATION_CORE_SDK_NAME",
     "OPTIMIZATION_CORE_SDK_VERSION",
+    "PERSONALIZATIONS_CACHE_KEY",
+    "PREVIEW_PANEL_SIGNALS_SYMBOL",
+    "PREVIEW_PANEL_SIGNAL_FNS_SYMBOL",
+    "PROFILE_CACHE_KEY",
+    "PersonalizationBase",
     "PersonalizationStateful",
     "PersonalizationStateless",
     "PersonalizedEntryResolver",
-    "ValuePresence",
     "batch",
-    "createScopedLogger",
     "effect",
     "guardedBy",
-    "logger",
+    "signalFns",
     "signals"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {