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

package/dist/index.cjs

@@ -1,5 +1,13 @@
 "use strict";
 var __webpack_modules__ = {
+    "./src/api-schemas.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        var _contentful_optimization_api_client_api_schemas__rspack_import_0 = __webpack_require__("@contentful/optimization-api-client/api-schemas");
+        if (__webpack_require__.o(_contentful_optimization_api_client_api_schemas__rspack_import_0, "PartialProfile")) __webpack_require__.d(__webpack_exports__, {
+            PartialProfile: function() {
+                return _contentful_optimization_api_client_api_schemas__rspack_import_0.PartialProfile;
+            }
+        });
+    },
     "./src/constants.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             ANONYMOUS_ID_COOKIE: ()=>ANONYMOUS_ID_COOKIE,
@@ -11,10 +19,10 @@ var __webpack_modules__ = {
             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
+            PROFILE_CACHE_KEY: ()=>PROFILE_CACHE_KEY,
+            SELECTED_OPTIMIZATIONS_CACHE_KEY: ()=>SELECTED_OPTIMIZATIONS_CACHE_KEY
         });
-        const OPTIMIZATION_CORE_SDK_VERSION = "0.1.0-alpha10";
+        const OPTIMIZATION_CORE_SDK_VERSION = "0.1.0-alpha12";
         const OPTIMIZATION_CORE_SDK_NAME = "@contentful/optimization-core";
         const ANONYMOUS_ID_COOKIE = 'ctfl-opt-aid';
         const ANONYMOUS_ID_KEY = '__ctfl_opt_anonymous_id__';
@@ -22,7 +30,7 @@ var __webpack_modules__ = {
         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 SELECTED_OPTIMIZATIONS_CACHE_KEY = '__ctfl_opt_selected-optimizations__';
         const ANONYMOUS_ID_COOKIE_LEGACY = 'ntaid';
         const ANONYMOUS_ID_KEY_LEGACY = '__nt_anonymous_id__';
     },
@@ -33,6 +41,9 @@ var __webpack_modules__ = {
         });
         const PREVIEW_PANEL_SIGNALS_SYMBOL = Symbol.for('ctfl.optimization.preview.signals');
         const PREVIEW_PANEL_SIGNAL_FNS_SYMBOL = Symbol.for('ctfl.optimization.preview.signalFns');
+    },
+    "@contentful/optimization-api-client/api-schemas" (module) {
+        module.exports = require("@contentful/optimization-api-client/api-schemas");
     }
 };
 var __webpack_module_cache__ = {};
@@ -45,6 +56,15 @@ function __webpack_require__(moduleId) {
     __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, {
@@ -70,18 +90,24 @@ var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
-        OPTIMIZATION_CORE_SDK_NAME: ()=>constants.OPTIMIZATION_CORE_SDK_NAME,
+        HoverBuilderArgs: ()=>HoverBuilderArgs,
         ANONYMOUS_ID_KEY: ()=>constants.ANONYMOUS_ID_KEY,
+        OPTIMIZATION_CORE_SDK_NAME: ()=>constants.OPTIMIZATION_CORE_SDK_NAME,
         OPTIMIZATION_CORE_SDK_VERSION: ()=>constants.OPTIMIZATION_CORE_SDK_VERSION,
+        DEFAULT_PAGE_PROPERTIES: ()=>DEFAULT_PAGE_PROPERTIES,
         PROFILE_CACHE_KEY: ()=>constants.PROFILE_CACHE_KEY,
-        PersonalizationStateful: ()=>personalization_PersonalizationStateful,
+        SELECTED_OPTIMIZATIONS_CACHE_KEY: ()=>constants.SELECTED_OPTIMIZATIONS_CACHE_KEY,
+        PageViewBuilderArgs: ()=>PageViewBuilderArgs,
+        ScreenViewBuilderArgs: ()=>ScreenViewBuilderArgs,
         batch: ()=>signals_core_namespaceObject.batch,
-        AnalyticsStateless: ()=>analytics_AnalyticsStateless,
-        PersonalizationStateless: ()=>personalization_PersonalizationStateless,
+        toObservable: ()=>toObservable,
         InterceptorManager: ()=>InterceptorManager,
-        AnalyticsStateful: ()=>analytics_AnalyticsStateful,
         CONSENT_KEY: ()=>constants.CONSENT_KEY,
+        FlagViewBuilderArgs: ()=>FlagViewBuilderArgs,
         signals: ()=>signals,
+        TrackBuilderArgs: ()=>TrackBuilderArgs,
+        ViewBuilderArgs: ()=>ViewBuilderArgs,
+        toDistinctObservable: ()=>toDistinctObservable,
         ANONYMOUS_ID_KEY_LEGACY: ()=>constants.ANONYMOUS_ID_KEY_LEGACY,
         CoreStateless: ()=>src_CoreStateless,
         PREVIEW_PANEL_SIGNAL_FNS_SYMBOL: ()=>symbols.PREVIEW_PANEL_SIGNAL_FNS_SYMBOL,
@@ -89,18 +115,338 @@ var __webpack_exports__ = {};
         MergeTagValueResolver: ()=>resolvers_MergeTagValueResolver,
         signalFns: ()=>signalFns,
         DEBUG_FLAG_KEY: ()=>constants.DEBUG_FLAG_KEY,
+        IdentifyBuilderArgs: ()=>IdentifyBuilderArgs,
         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,
+        ClickBuilderArgs: ()=>ClickBuilderArgs,
+        OptimizedEntryResolver: ()=>resolvers_OptimizedEntryResolver,
+        UniversalEventBuilderArgs: ()=>UniversalEventBuilderArgs,
+        EntryInteractionBuilderArgsBase: ()=>EntryInteractionBuilderArgsBase,
         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
+        EventBuilder: ()=>events_EventBuilder
     });
     const signals_core_namespaceObject = require("@preact/signals-core");
+    const external_es_toolkit_namespaceObject = require("es-toolkit");
+    function isNonNullish(value) {
+        return null != value;
+    }
+    function toError(value) {
+        if (value instanceof Error) return value;
+        return new Error(`Subscriber threw non-Error value: ${String(value)}`);
+    }
+    function toObservable(s) {
+        return {
+            get current () {
+                return (0, external_es_toolkit_namespaceObject.cloneDeep)(s.value);
+            },
+            subscribe (next) {
+                const dispose = (0, signals_core_namespaceObject.effect)(()=>{
+                    next((0, external_es_toolkit_namespaceObject.cloneDeep)(s.value));
+                });
+                return {
+                    unsubscribe: dispose
+                };
+            },
+            subscribeOnce (next) {
+                let closed = false;
+                let isEffectActive = false;
+                let dispose = ()=>void 0;
+                const stop = ()=>{
+                    if (closed) return;
+                    closed = true;
+                    if (isEffectActive) dispose();
+                };
+                dispose = (0, signals_core_namespaceObject.effect)(()=>{
+                    if (closed) return;
+                    const { value } = s;
+                    if (!isNonNullish(value)) return;
+                    closed = true;
+                    let callbackError = null;
+                    try {
+                        next((0, external_es_toolkit_namespaceObject.cloneDeep)(value));
+                    } catch (error) {
+                        callbackError = toError(error);
+                    }
+                    if (isEffectActive) dispose();
+                    else queueMicrotask(dispose);
+                    if (callbackError) throw callbackError;
+                });
+                isEffectActive = true;
+                return {
+                    unsubscribe: stop
+                };
+            }
+        };
+    }
+    function toDistinctObservable(s, isEqual) {
+        const observable = toObservable(s);
+        return {
+            get current () {
+                return observable.current;
+            },
+            subscribe (next) {
+                let hasPrevious = false;
+                let previous = (0, external_es_toolkit_namespaceObject.cloneDeep)(observable.current);
+                return observable.subscribe((value)=>{
+                    if (hasPrevious && isEqual(previous, value)) return;
+                    hasPrevious = true;
+                    previous = (0, external_es_toolkit_namespaceObject.cloneDeep)(value);
+                    next(value);
+                });
+            },
+            subscribeOnce (next) {
+                return observable.subscribeOnce(next);
+            }
+        };
+    }
+    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 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_selectedOptimizations = (0, signals_core_namespaceObject.signal)();
+    const canOptimize = (0, signals_core_namespaceObject.computed)(()=>void 0 !== signals_selectedOptimizations.value);
+    const signals_profile = (0, signals_core_namespaceObject.signal)();
+    const signals = {
+        blockedEvent,
+        changes: signals_changes,
+        consent,
+        event: signals_event,
+        online,
+        previewPanelAttached,
+        previewPanelOpen,
+        selectedOptimizations: signals_selectedOptimizations,
+        canOptimize,
+        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
+    };
+    var constants = __webpack_require__("./src/constants.ts");
+    const optimization_api_client_namespaceObject = require("@contentful/optimization-api-client");
+    const logger_namespaceObject = require("@contentful/optimization-api-client/logger");
+    var api_schemas_ = __webpack_require__("@contentful/optimization-api-client/api-schemas");
+    const object_namespaceObject = require("es-toolkit/object");
+    const mini_namespaceObject = require("zod/mini");
+    const UniversalEventBuilderArgs = mini_namespaceObject.object({
+        campaign: mini_namespaceObject.optional(api_schemas_.Campaign),
+        locale: mini_namespaceObject.optional(mini_namespaceObject.string()),
+        location: mini_namespaceObject.optional(api_schemas_.GeoLocation),
+        page: mini_namespaceObject.optional(api_schemas_.Page),
+        screen: mini_namespaceObject.optional(api_schemas_.Screen),
+        userAgent: mini_namespaceObject.optional(mini_namespaceObject.string())
+    });
+    const EntryInteractionBuilderArgsBase = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
+        componentId: mini_namespaceObject.string(),
+        experienceId: mini_namespaceObject.optional(mini_namespaceObject.string()),
+        variantIndex: mini_namespaceObject.optional(mini_namespaceObject.number())
+    });
+    const ViewBuilderArgs = mini_namespaceObject.extend(EntryInteractionBuilderArgsBase, {
+        sticky: mini_namespaceObject.optional(mini_namespaceObject.boolean()),
+        viewId: mini_namespaceObject.string(),
+        viewDurationMs: mini_namespaceObject.number()
+    });
+    const FlagViewBuilderArgs = mini_namespaceObject.extend(EntryInteractionBuilderArgsBase, {
+        viewId: mini_namespaceObject.optional(mini_namespaceObject.string()),
+        viewDurationMs: mini_namespaceObject.optional(mini_namespaceObject.number())
+    });
+    const ClickBuilderArgs = EntryInteractionBuilderArgsBase;
+    const HoverBuilderArgs = mini_namespaceObject.extend(EntryInteractionBuilderArgsBase, {
+        hoverId: mini_namespaceObject.string(),
+        hoverDurationMs: mini_namespaceObject.number()
+    });
+    const IdentifyBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
+        traits: mini_namespaceObject.optional(api_schemas_.Traits),
+        userId: mini_namespaceObject.string()
+    });
+    const PageViewBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
+        properties: mini_namespaceObject.optional(mini_namespaceObject.partial(api_schemas_.Page))
+    });
+    const ScreenViewBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
+        name: mini_namespaceObject.string(),
+        properties: api_schemas_.Properties
+    });
+    const TrackBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
+        event: mini_namespaceObject.string(),
+        properties: mini_namespaceObject.optional(mini_namespaceObject.prefault(api_schemas_.Properties, {}))
+    });
+    const DEFAULT_PAGE_PROPERTIES = {
+        path: '',
+        query: {},
+        referrer: '',
+        search: '',
+        title: '',
+        url: ''
+    };
+    class EventBuilder {
+        app;
+        channel;
+        library;
+        getLocale;
+        getPageProperties;
+        getUserAgent;
+        constructor(config){
+            const { app, channel, library, getLocale, getPageProperties, getUserAgent } = config;
+            this.app = app;
+            this.channel = channel;
+            this.library = library;
+            this.getLocale = getLocale ?? (()=>'en-US');
+            this.getPageProperties = getPageProperties ?? (()=>DEFAULT_PAGE_PROPERTIES);
+            this.getUserAgent = getUserAgent ?? (()=>void 0);
+        }
+        buildUniversalEventProperties({ campaign = {}, locale, location, page, screen, userAgent }) {
+            const timestamp = new Date().toISOString();
+            return {
+                channel: this.channel,
+                context: {
+                    app: this.app,
+                    campaign,
+                    gdpr: {
+                        isConsentGiven: true
+                    },
+                    library: this.library,
+                    locale: locale ?? this.getLocale() ?? 'en-US',
+                    location,
+                    page: page ?? this.getPageProperties(),
+                    screen,
+                    userAgent: userAgent ?? this.getUserAgent()
+                },
+                messageId: crypto.randomUUID(),
+                originalTimestamp: timestamp,
+                sentAt: timestamp,
+                timestamp
+            };
+        }
+        buildEntryInteractionBase(universal, componentId, experienceId, variantIndex) {
+            return {
+                ...this.buildUniversalEventProperties(universal),
+                componentType: 'Entry',
+                componentId,
+                experienceId,
+                variantIndex: variantIndex ?? 0
+            };
+        }
+        buildView(args) {
+            const { componentId, viewId, experienceId, variantIndex, viewDurationMs, ...universal } = (0, api_schemas_.parseWithFriendlyError)(ViewBuilderArgs, args);
+            return {
+                ...this.buildEntryInteractionBase(universal, componentId, experienceId, variantIndex),
+                type: 'component',
+                viewId,
+                viewDurationMs
+            };
+        }
+        buildClick(args) {
+            const { componentId, experienceId, variantIndex, ...universal } = (0, api_schemas_.parseWithFriendlyError)(ClickBuilderArgs, args);
+            return {
+                ...this.buildEntryInteractionBase(universal, componentId, experienceId, variantIndex),
+                type: 'component_click'
+            };
+        }
+        buildHover(args) {
+            const { hoverId, componentId, experienceId, hoverDurationMs, variantIndex, ...universal } = (0, api_schemas_.parseWithFriendlyError)(HoverBuilderArgs, args);
+            return {
+                ...this.buildEntryInteractionBase(universal, componentId, experienceId, variantIndex),
+                type: 'component_hover',
+                hoverId,
+                hoverDurationMs
+            };
+        }
+        buildFlagView(args) {
+            const { componentId, experienceId, variantIndex, viewId, viewDurationMs, ...universal } = (0, api_schemas_.parseWithFriendlyError)(FlagViewBuilderArgs, args);
+            return {
+                ...this.buildEntryInteractionBase(universal, componentId, experienceId, variantIndex),
+                ...void 0 === viewDurationMs ? {} : {
+                    viewDurationMs
+                },
+                ...void 0 === viewId ? {} : {
+                    viewId
+                },
+                type: 'component',
+                componentType: 'Variable'
+            };
+        }
+        buildIdentify(args) {
+            const { traits = {}, userId, ...universal } = (0, api_schemas_.parseWithFriendlyError)(IdentifyBuilderArgs, args);
+            return {
+                ...this.buildUniversalEventProperties(universal),
+                type: 'identify',
+                traits,
+                userId
+            };
+        }
+        buildPageView(args = {}) {
+            const { properties = {}, ...universal } = (0, api_schemas_.parseWithFriendlyError)(PageViewBuilderArgs, args);
+            const pageProperties = this.getPageProperties();
+            const merged = (0, object_namespaceObject.merge)({
+                ...pageProperties,
+                title: pageProperties.title ?? DEFAULT_PAGE_PROPERTIES.title
+            }, properties);
+            const { context: { screen: _, ...universalContext }, ...universalProperties } = this.buildUniversalEventProperties(universal);
+            const context = (0, api_schemas_.parseWithFriendlyError)(api_schemas_.PageEventContext, universalContext);
+            return {
+                ...universalProperties,
+                context,
+                type: 'page',
+                properties: merged
+            };
+        }
+        buildScreenView(args) {
+            const { name, properties, ...universal } = (0, api_schemas_.parseWithFriendlyError)(ScreenViewBuilderArgs, args);
+            const { context: { page: _, ...universalContext }, ...universalProperties } = this.buildUniversalEventProperties(universal);
+            const context = (0, api_schemas_.parseWithFriendlyError)(api_schemas_.ScreenEventContext, universalContext);
+            return {
+                ...universalProperties,
+                context,
+                type: 'screen',
+                name,
+                properties
+            };
+        }
+        buildTrack(args) {
+            const { event, properties = {}, ...universal } = (0, api_schemas_.parseWithFriendlyError)(TrackBuilderArgs, args);
+            return {
+                ...this.buildUniversalEventProperties(universal),
+                type: 'track',
+                event,
+                properties
+            };
+        }
+    }
+    const events_EventBuilder = EventBuilder;
+    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((0, external_es_toolkit_namespaceObject.cloneDeep)(acc));
+            return acc;
+        }
+    }
     const FlagsResolver = {
         resolve (changes) {
             if (!changes) return {};
@@ -112,9 +458,7 @@ var __webpack_exports__ = {};
         }
     };
     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 logger = (0, logger_namespaceObject.createScopedLogger)('Optimization');
     const RESOLUTION_WARNING_BASE = 'Could not resolve Merge Tag value:';
     const getAtPath = (value, path)=>{
         if (!value || 'object' != typeof value) return;
@@ -147,9 +491,9 @@ var __webpack_exports__ = {};
             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`);
+            if (!(0, api_schemas_.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) {
+            if (!api_schemas_.Profile.safeParse(profile).success) {
                 logger.warn(`${RESOLUTION_WARNING_BASE} no valid profile`);
                 return fallback;
             }
@@ -157,177 +501,285 @@ var __webpack_exports__ = {};
         }
     };
     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;
+    const OptimizedEntryResolver_logger = (0, logger_namespaceObject.createScopedLogger)('Optimization');
+    const OptimizedEntryResolver_RESOLUTION_WARNING_BASE = 'Could not resolve optimized entry variant:';
+    function resolve(entry, selectedOptimizations) {
+        OptimizedEntryResolver_logger.debug(`Resolving optimized entry for baseline entry ${entry.sys.id}`);
+        if (!selectedOptimizations?.length) {
+            OptimizedEntryResolver_logger.warn(`${OptimizedEntryResolver_RESOLUTION_WARNING_BASE} no selectedOptimizations exist for the current profile`);
+            return {
+                entry
+            };
+        }
+        if (!(0, api_schemas_.isOptimizedEntry)(entry)) {
+            OptimizedEntryResolver_logger.warn(`${OptimizedEntryResolver_RESOLUTION_WARNING_BASE} entry ${entry.sys.id} is not optimized`);
+            return {
+                entry
+            };
+        }
+        const optimizationEntry = OptimizedEntryResolver.getOptimizationEntry({
+            optimizedEntry: entry,
+            selectedOptimizations
+        }, true);
+        if (!optimizationEntry) {
+            OptimizedEntryResolver_logger.warn(`${OptimizedEntryResolver_RESOLUTION_WARNING_BASE} could not find an optimization entry for ${entry.sys.id}`);
+            return {
+                entry
+            };
+        }
+        const selectedOptimization = OptimizedEntryResolver.getSelectedOptimization({
+            optimizationEntry,
+            selectedOptimizations
+        }, true);
+        const selectedVariantIndex = selectedOptimization?.variantIndex ?? 0;
+        if (0 === selectedVariantIndex) {
+            OptimizedEntryResolver_logger.debug(`Resolved optimization entry for entry ${entry.sys.id} is baseline`);
+            return {
+                entry
+            };
+        }
+        const selectedVariant = OptimizedEntryResolver.getSelectedVariant({
+            optimizedEntry: entry,
+            optimizationEntry,
+            selectedVariantIndex
+        }, true);
+        if (!selectedVariant) {
+            OptimizedEntryResolver_logger.warn(`${OptimizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a valid replacement variant entry for ${entry.sys.id}`);
+            return {
+                entry
+            };
+        }
+        const selectedVariantEntry = OptimizedEntryResolver.getSelectedVariantEntry({
+            optimizationEntry,
+            selectedVariant
+        }, true);
+        if (selectedVariantEntry) OptimizedEntryResolver_logger.debug(`Entry ${entry.sys.id} has been resolved to variant entry ${selectedVariantEntry.sys.id}`);
+        else {
+            OptimizedEntryResolver_logger.warn(`${OptimizedEntryResolver_RESOLUTION_WARNING_BASE} could not find a valid replacement variant entry for ${entry.sys.id}`);
+            return {
+                entry
+            };
+        }
+        return {
+            entry: selectedVariantEntry,
+            selectedOptimization
+        };
+    }
+    const OptimizedEntryResolver = {
+        getOptimizationEntry ({ optimizedEntry, selectedOptimizations }, skipValidation = false) {
+            if (!skipValidation && (!selectedOptimizations.length || !(0, api_schemas_.isOptimizedEntry)(optimizedEntry))) return;
+            const optimizationEntry = optimizedEntry.fields.nt_experiences.filter((maybeOptimization)=>(0, api_schemas_.isOptimizationEntry)(maybeOptimization)).find((optimizationEntry)=>selectedOptimizations.some(({ experienceId })=>experienceId === optimizationEntry.fields.nt_experience_id));
+            return optimizationEntry;
         },
-        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;
+        getSelectedOptimization ({ optimizationEntry, selectedOptimizations }, skipValidation = false) {
+            if (!skipValidation && (!selectedOptimizations.length || !(0, api_schemas_.isOptimizationEntry)(optimizationEntry))) return;
+            const selectedOptimization = selectedOptimizations.find(({ experienceId })=>experienceId === optimizationEntry.fields.nt_experience_id);
+            return selectedOptimization;
         },
-        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;
+        getSelectedVariant ({ optimizedEntry, optimizationEntry, selectedVariantIndex }, skipValidation = false) {
+            if (!skipValidation && (!(0, api_schemas_.isOptimizedEntry)(optimizedEntry) || !(0, api_schemas_.isOptimizationEntry)(optimizationEntry))) return;
+            const relevantVariants = (0, api_schemas_.normalizeOptimizationConfig)(optimizationEntry.fields.nt_config).components.filter((component)=>(0, api_schemas_.isEntryReplacementComponent)(component) && !component.baseline.hidden).find((component)=>component.baseline.id === optimizedEntry.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;
+        getSelectedVariantEntry ({ optimizationEntry, selectedVariant }, skipValidation = false) {
+            if (!skipValidation && (!(0, api_schemas_.isOptimizationEntry)(optimizationEntry) || !(0, api_schemas_.isEntryReplacementVariant)(selectedVariant))) return;
+            const selectedVariantEntry = optimizationEntry.fields.nt_variants?.find((variant)=>variant.sys.id === selectedVariant.id);
+            return (0, api_schemas_.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, api_schemas_namespaceObject.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
-            };
-        }
+        resolve
     };
-    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);
-                });
-                return {
-                    unsubscribe: dispose
-                };
-            }
+    const resolvers_OptimizedEntryResolver = OptimizedEntryResolver;
+    class CoreBase {
+        api;
+        eventBuilder;
+        config;
+        flagsResolver = resolvers_FlagsResolver;
+        mergeTagValueResolver = resolvers_MergeTagValueResolver;
+        optimizedEntryResolver = resolvers_OptimizedEntryResolver;
+        interceptors = {
+            event: new InterceptorManager(),
+            state: new InterceptorManager()
         };
+        constructor(config, api = {}){
+            this.config = config;
+            const { eventBuilder, logLevel, environment, clientId, fetchOptions } = config;
+            logger_namespaceObject.logger.addSink(new logger_namespaceObject.ConsoleLogSink(logLevel));
+            const apiConfig = {
+                clientId,
+                environment,
+                fetchOptions,
+                experience: api.experience,
+                insights: api.insights
+            };
+            this.api = new optimization_api_client_namespaceObject.ApiClient(apiConfig);
+            this.eventBuilder = new events_EventBuilder(eventBuilder ?? {
+                channel: 'server',
+                library: {
+                    name: constants.OPTIMIZATION_CORE_SDK_NAME,
+                    version: constants.OPTIMIZATION_CORE_SDK_VERSION
+                }
+            });
+        }
+        getFlag(name, changes) {
+            return this.flagsResolver.resolve(changes)[name];
+        }
+        resolveOptimizedEntry(entry, selectedOptimizations) {
+            return this.optimizedEntryResolver.resolve(entry, selectedOptimizations);
+        }
+        getMergeTagValue(embeddedEntryNodeTarget, profile) {
+            return this.mergeTagValueResolver.resolve(embeddedEntryNodeTarget, profile);
+        }
     }
-    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 src_CoreBase = CoreBase;
+    const predicate_namespaceObject = require("es-toolkit/predicate");
+    const coreLogger = (0, logger_namespaceObject.createScopedLogger)('CoreStateful');
+    const CONSENT_EVENT_TYPE_MAP = {
+        trackView: 'component',
+        trackFlagView: 'component',
+        trackClick: 'component_click',
+        trackHover: 'component_hover'
     };
-    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);
+    class CoreStatefulEventEmitter extends src_CoreBase {
+        flagObservables = new Map();
+        getFlag(name, changes = signals_changes.value) {
+            const value = super.getFlag(name, changes);
+            const payload = this.buildFlagViewBuilderArgs(name, changes);
+            this.trackFlagView(payload).catch((error)=>{
+                logger_namespaceObject.logger.warn(`Failed to emit "flag view" event for "${name}"`, String(error));
             });
-        };
+            return value;
+        }
+        resolveOptimizedEntry(entry, selectedOptimizations = signals_selectedOptimizations.value) {
+            return super.resolveOptimizedEntry(entry, selectedOptimizations);
+        }
+        getMergeTagValue(embeddedEntryNodeTarget, profile = signals_profile.value) {
+            return super.getMergeTagValue(embeddedEntryNodeTarget, profile);
+        }
+        async identify(payload) {
+            const { profile, ...builderArgs } = payload;
+            return await this.sendExperienceEvent('identify', [
+                payload
+            ], this.eventBuilder.buildIdentify(builderArgs), profile);
+        }
+        async page(payload = {}) {
+            const { profile, ...builderArgs } = payload;
+            return await this.sendExperienceEvent('page', [
+                payload
+            ], this.eventBuilder.buildPageView(builderArgs), profile);
+        }
+        async screen(payload) {
+            const { profile, ...builderArgs } = payload;
+            return await this.sendExperienceEvent('screen', [
+                payload
+            ], this.eventBuilder.buildScreenView(builderArgs), profile);
+        }
+        async track(payload) {
+            const { profile, ...builderArgs } = payload;
+            return await this.sendExperienceEvent('track', [
+                payload
+            ], this.eventBuilder.buildTrack(builderArgs), profile);
+        }
+        async trackView(payload) {
+            const { profile, ...builderArgs } = payload;
+            let result;
+            if (payload.sticky) result = await this.sendExperienceEvent('trackView', [
+                payload
+            ], this.eventBuilder.buildView(builderArgs), profile);
+            await this.sendInsightsEvent('trackView', [
+                payload
+            ], this.eventBuilder.buildView(builderArgs), profile);
+            return result;
+        }
+        async trackClick(payload) {
+            await this.sendInsightsEvent('trackClick', [
+                payload
+            ], this.eventBuilder.buildClick(payload));
+        }
+        async trackHover(payload) {
+            await this.sendInsightsEvent('trackHover', [
+                payload
+            ], this.eventBuilder.buildHover(payload));
+        }
+        async trackFlagView(payload) {
+            await this.sendInsightsEvent('trackFlagView', [
+                payload
+            ], this.eventBuilder.buildFlagView(payload));
+        }
+        hasConsent(name) {
+            const { [name]: mappedEventType } = CONSENT_EVENT_TYPE_MAP;
+            const isAllowed = void 0 !== mappedEventType ? this.allowedEventTypes.includes(mappedEventType) : this.allowedEventTypes.some((eventType)=>eventType === name);
+            return !!consent.value || isAllowed;
+        }
+        onBlockedByConsent(name, args) {
+            coreLogger.warn(`Event "${name}" was blocked due to lack of consent; payload: ${JSON.stringify(args)}`);
+            this.reportBlockedEvent('consent', name, args);
+        }
+        async sendExperienceEvent(method, args, event, _profile) {
+            if (!this.hasConsent(method)) return void this.onBlockedByConsent(method, args);
+            return await this.experienceQueue.send(event);
+        }
+        async sendInsightsEvent(method, args, event, _profile) {
+            if (!this.hasConsent(method)) return void this.onBlockedByConsent(method, args);
+            await this.insightsQueue.send(event);
+        }
+        buildFlagViewBuilderArgs(name, changes = signals_changes.value) {
+            const change = changes?.find((candidate)=>candidate.key === name);
+            return {
+                componentId: name,
+                experienceId: change?.meta.experienceId,
+                variantIndex: change?.meta.variantIndex
+            };
+        }
+        getFlagObservable(name) {
+            const existingObservable = this.flagObservables.get(name);
+            if (existingObservable) return existingObservable;
+            const trackFlagView = this.trackFlagView.bind(this);
+            const buildFlagViewBuilderArgs = this.buildFlagViewBuilderArgs.bind(this);
+            const valueSignal = signalFns.computed(()=>super.getFlag(name, signals_changes.value));
+            const distinctObservable = toDistinctObservable(valueSignal, predicate_namespaceObject.isEqual);
+            const trackedObservable = {
+                get current () {
+                    const { current: value } = distinctObservable;
+                    const payload = buildFlagViewBuilderArgs(name, signals_changes.value);
+                    trackFlagView(payload).catch((error)=>{
+                        logger_namespaceObject.logger.warn(`Failed to emit "flag view" event for "${name}"`, String(error));
+                    });
+                    return value;
+                },
+                subscribe: (next)=>distinctObservable.subscribe((value)=>{
+                        const payload = buildFlagViewBuilderArgs(name, signals_changes.value);
+                        trackFlagView(payload).catch((error)=>{
+                            logger_namespaceObject.logger.warn(`Failed to emit "flag view" event for "${name}"`, String(error));
+                        });
+                        next(value);
+                    }),
+                subscribeOnce: (next)=>distinctObservable.subscribeOnce((value)=>{
+                        const payload = buildFlagViewBuilderArgs(name, signals_changes.value);
+                        trackFlagView(payload).catch((error)=>{
+                            logger_namespaceObject.logger.warn(`Failed to emit "flag view" event for "${name}"`, String(error));
+                        });
+                        next(value);
+                    })
+            };
+            this.flagObservables.set(name, trackedObservable);
+            return trackedObservable;
+        }
+        reportBlockedEvent(reason, method, args) {
+            const event = {
+                reason,
+                method,
+                args
+            };
+            try {
+                this.onEventBlocked?.(event);
+            } catch (error) {
+                coreLogger.warn(`onEventBlocked callback failed for method "${method}"`, error);
+            }
+            blockedEvent.value = event;
+        }
     }
+    const src_CoreStatefulEventEmitter = CoreStatefulEventEmitter;
     const toPositiveInt = (value, fallback)=>{
         if (!Number.isFinite(value) || void 0 === value || value < 1) return fallback;
         return Math.floor(value);
@@ -337,6 +789,7 @@ var __webpack_exports__ = {};
         return Math.min(1, Math.max(0, value));
     };
     const DEFAULT_QUEUE_FLUSH_POLICY = {
+        flushIntervalMs: 30000,
         baseBackoffMs: 500,
         maxBackoffMs: 30000,
         jitterRatio: 0.2,
@@ -344,17 +797,19 @@ var __webpack_exports__ = {};
         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));
+        const configuredPolicy = policy ?? {};
+        const baseBackoffMs = toPositiveInt(configuredPolicy.baseBackoffMs, defaults.baseBackoffMs);
+        const maxBackoffMs = Math.max(baseBackoffMs, toPositiveInt(configuredPolicy.maxBackoffMs, defaults.maxBackoffMs));
         return {
+            flushIntervalMs: toPositiveInt(configuredPolicy.flushIntervalMs, defaults.flushIntervalMs),
             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
+            jitterRatio: toRatio(configuredPolicy.jitterRatio, defaults.jitterRatio),
+            maxConsecutiveFailures: toPositiveInt(configuredPolicy.maxConsecutiveFailures, defaults.maxConsecutiveFailures),
+            circuitOpenMs: toPositiveInt(configuredPolicy.circuitOpenMs, defaults.circuitOpenMs),
+            onCircuitOpen: configuredPolicy.onCircuitOpen,
+            onFlushFailure: configuredPolicy.onFlushFailure,
+            onFlushRecovered: configuredPolicy.onFlushRecovered
         };
     };
     const computeQueueFlushRetryDelayMs = (options)=>{
@@ -380,6 +835,23 @@ var __webpack_exports__ = {};
             circuitOpenUntil
         };
     };
+    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 QueueFlushRuntime {
         circuitOpenUntil = 0;
         flushFailureCount = 0;
@@ -484,463 +956,186 @@ var __webpack_exports__ = {};
             }
         }
     }
-    const ProductBase_logger = (0, logger_namespaceObject.createScopedLogger)('ProductBase');
-    const defaultAllowedEvents = [
-        'identify',
-        'page',
-        'screen'
-    ];
-    class ProductBase {
-        allowedEventTypes;
-        builder;
-        api;
-        interceptors;
-        onEventBlocked;
+    const ExperienceQueue_coreLogger = (0, logger_namespaceObject.createScopedLogger)('CoreStateful');
+    class ExperienceQueue {
+        experienceApi;
+        eventInterceptors;
+        flushRuntime;
+        getAnonymousId;
+        offlineMaxEvents;
+        onOfflineDrop;
+        queuedExperienceEvents = new Set();
+        stateInterceptors;
         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 { experienceApi, eventInterceptors, flushPolicy, getAnonymousId, offlineMaxEvents, onOfflineDrop, stateInterceptors } = options;
+            this.experienceApi = experienceApi;
+            this.eventInterceptors = eventInterceptors;
+            this.getAnonymousId = getAnonymousId;
+            this.offlineMaxEvents = offlineMaxEvents;
+            this.onOfflineDrop = onOfflineDrop;
+            this.stateInterceptors = stateInterceptors;
+            this.flushRuntime = new QueueFlushRuntime({
+                policy: flushPolicy,
+                onRetry: ()=>{
+                    this.flush();
+                },
+                onCallbackError: (callbackName, error)=>{
+                    ExperienceQueue_coreLogger.warn(`Experience flush policy callback "${callbackName}" failed`, error);
+                }
+            });
         }
-    }
-    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);
-            };
+        clearScheduledRetry() {
+            this.flushRuntime.clearScheduledRetry();
         }
-        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;
-                };
-            }
-            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);
-                };
-            }
-            ctx.access = get && set ? {
-                get: get,
-                set: set
-            } : get ? {
-                get: get
-            } : {
-                set: set
-            };
+        async send(event) {
+            const intercepted = await this.eventInterceptors.run(event);
+            const validEvent = (0, api_schemas_.parseWithFriendlyError)(api_schemas_.ExperienceEvent, intercepted);
+            signals_event.value = validEvent;
+            if (online.value) return await this.upsertProfile([
+                validEvent
+            ]);
+            ExperienceQueue_coreLogger.debug(`Queueing ${validEvent.type} event`, validEvent);
+            this.enqueueEvent(validEvent);
+        }
+        async flush(options = {}) {
+            const { force = false } = options;
+            if (this.flushRuntime.shouldSkip({
+                force,
+                isOnline: !!online.value
+            })) return;
+            if (0 === this.queuedExperienceEvents.size) return void this.flushRuntime.clearScheduledRetry();
+            ExperienceQueue_coreLogger.debug('Flushing offline Experience event queue');
+            const queuedEvents = Array.from(this.queuedExperienceEvents);
+            this.flushRuntime.markFlushStarted();
             try {
-                return dec(value, ctx);
+                const sendSuccess = await this.tryUpsertQueuedEvents(queuedEvents);
+                if (sendSuccess) {
+                    queuedEvents.forEach((queuedEvent)=>{
+                        this.queuedExperienceEvents.delete(queuedEvent);
+                    });
+                    this.flushRuntime.handleFlushSuccess();
+                } else this.flushRuntime.handleFlushFailure({
+                    queuedBatches: this.queuedExperienceEvents.size > 0 ? 1 : 0,
+                    queuedEvents: this.queuedExperienceEvents.size
+                });
             } finally{
-                decoratorFinishedRef.v = true;
+                this.flushRuntime.markFlushFinished();
             }
         }
-        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");
+        enqueueEvent(event) {
+            let droppedEvents = [];
+            if (this.queuedExperienceEvents.size >= this.offlineMaxEvents) {
+                const dropCount = this.queuedExperienceEvents.size - this.offlineMaxEvents + 1;
+                droppedEvents = this.dropOldestEvents(dropCount);
+                if (droppedEvents.length > 0) ExperienceQueue_coreLogger.warn(`Dropped ${droppedEvents.length} oldest offline event(s) due to queue limit (${this.offlineMaxEvents})`);
             }
+            this.queuedExperienceEvents.add(event);
+            if (droppedEvents.length > 0) this.invokeOfflineDropCallback({
+                droppedCount: droppedEvents.length,
+                droppedEvents,
+                maxEvents: this.offlineMaxEvents,
+                queuedEvents: this.queuedExperienceEvents.size
+            });
         }
-        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);
-                }
-            }
-            if (0 === kind || 1 === kind) {
-                if (void 0 === init) init = function(instance, init) {
-                    return init;
-                };
-                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);
-                    });
-                } else if (2 === kind) ret.push(value);
-                else ret.push(function(instance, args) {
-                    return value.call(instance, args);
-                });
-                else Object.defineProperty(base, name, desc);
+        dropOldestEvents(count) {
+            const droppedEvents = [];
+            for(let index = 0; index < count; index += 1){
+                const oldestEvent = this.queuedExperienceEvents.values().next();
+                if (oldestEvent.done) break;
+                this.queuedExperienceEvents.delete(oldestEvent.value);
+                droppedEvents.push(oldestEvent.value);
             }
+            return droppedEvents;
         }
-        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);
-                }
+        invokeOfflineDropCallback(context) {
+            try {
+                this.onOfflineDrop?.(context);
+            } catch (error) {
+                ExperienceQueue_coreLogger.warn('Offline queue drop callback failed', error);
             }
-            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;
-                    }
-                }
-                return [
-                    defineMetadata(newClass, metadata),
-                    function() {
-                        for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
-                    }
-                ];
+        async tryUpsertQueuedEvents(events) {
+            try {
+                await this.upsertProfile(events);
+                return true;
+            } catch (error) {
+                ExperienceQueue_coreLogger.warn('Experience queue flush request threw an error', error);
+                return false;
             }
         }
-        function defineMetadata(Class, metadata) {
-            return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
-                configurable: true,
-                enumerable: true,
-                value: metadata
+        async upsertProfile(events) {
+            const anonymousId = this.getAnonymousId();
+            if (anonymousId) ExperienceQueue_coreLogger.debug(`Anonymous ID found: ${anonymousId}`);
+            const data = await this.experienceApi.upsertProfile({
+                profileId: anonymousId ?? signals_profile.value?.id,
+                events
             });
+            await this.updateOutputSignals(data);
+            return data;
         }
-        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);
-                }
-            };
-        };
-    }
-    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"
-                ]
-            ], []));
+        async updateOutputSignals(data) {
+            const intercepted = await this.stateInterceptors.run(data);
+            const { changes, profile, selectedOptimizations } = 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_selectedOptimizations.value, selectedOptimizations)) signals_selectedOptimizations.value = selectedOptimizations;
+            });
         }
-        queue = (_initProto(this), new Map());
+    }
+    const InsightsQueue_coreLogger = (0, logger_namespaceObject.createScopedLogger)('CoreStateful');
+    const MAX_QUEUED_INSIGHTS_EVENTS = 25;
+    class InsightsQueue {
+        eventInterceptors;
+        flushIntervalMs;
         flushRuntime;
-        states = {
-            blockedEventStream: toObservable(blockedEvent),
-            eventStream: toObservable(signals_event),
-            profile: toObservable(signals_profile)
-        };
+        insightsApi;
+        queuedInsightsByProfile = new Map();
+        insightsPeriodicFlushTimer;
         constructor(options){
-            const { api, builder, config, interceptors } = options;
-            super({
-                api,
-                builder,
-                config,
-                interceptors
-            });
-            this.applyDefaults(config?.defaults);
+            const { eventInterceptors, flushPolicy, insightsApi } = options;
+            const { flushIntervalMs } = flushPolicy;
+            this.eventInterceptors = eventInterceptors;
+            this.flushIntervalMs = flushIntervalMs;
+            this.insightsApi = insightsApi;
             this.flushRuntime = new QueueFlushRuntime({
-                policy: resolveQueueFlushPolicy(config?.queuePolicy),
+                policy: flushPolicy,
                 onRetry: ()=>{
                     this.flush();
                 },
                 onCallbackError: (callbackName, error)=>{
-                    AnalyticsStateful_logger.warn(`Analytics flush policy callback "${callbackName}" failed`, error);
+                    InsightsQueue_coreLogger.warn(`Insights flush policy callback "${callbackName}" failed`, error);
                 }
             });
-            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));
+        clearScheduledRetry() {
+            this.flushRuntime.clearScheduledRetry();
         }
-        async trackFlagView(payload) {
-            AnalyticsStateful_logger.debug(`Processing "flag view" event for ${payload.componentId}`);
-            await this.enqueueEvent(this.builder.buildFlagView(payload));
+        clearPeriodicFlushTimer() {
+            if (void 0 === this.insightsPeriodicFlushTimer) return;
+            clearInterval(this.insightsPeriodicFlushTimer);
+            this.insightsPeriodicFlushTimer = void 0;
         }
-        async enqueueEvent(event) {
+        async send(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);
+            if (!profile) return void InsightsQueue_coreLogger.warn('Attempting to emit an event without an Optimization profile');
+            const intercepted = await this.eventInterceptors.run(event);
+            const validEvent = (0, api_schemas_.parseWithFriendlyError)(api_schemas_.InsightsEvent, intercepted);
+            InsightsQueue_coreLogger.debug(`Queueing ${validEvent.type} event for profile ${profile.id}`, validEvent);
+            const queuedProfileEvents = this.queuedInsightsByProfile.get(profile.id);
             signals_event.value = validEvent;
             if (queuedProfileEvents) {
                 queuedProfileEvents.profile = profile;
                 queuedProfileEvents.events.push(validEvent);
-            } else this.queue.set(profileId, {
+            } else this.queuedInsightsByProfile.set(profile.id, {
                 profile,
                 events: [
                     validEvent
                 ]
             });
-            await this.flushMaxEvents();
-        }
-        async flushMaxEvents() {
-            if (this.getQueuedEventCount() >= MAX_QUEUED_EVENTS) await this.flush();
+            this.ensurePeriodicFlushTimer();
+            if (this.getQueuedEventCount() >= MAX_QUEUED_INSIGHTS_EVENTS) await this.flush();
+            this.reconcilePeriodicFlushTimer();
         }
         async flush(options = {}) {
             const { force = false } = options;
@@ -948,14 +1143,18 @@ var __webpack_exports__ = {};
                 force,
                 isOnline: !!online.value
             })) return;
-            AnalyticsStateful_logger.debug('Flushing event queue');
+            InsightsQueue_coreLogger.debug('Flushing insights event queue');
             const batches = this.createBatches();
-            if (!batches.length) return void this.flushRuntime.clearScheduledRetry();
+            if (!batches.length) {
+                this.flushRuntime.clearScheduledRetry();
+                this.reconcilePeriodicFlushTimer();
+                return;
+            }
             this.flushRuntime.markFlushStarted();
             try {
                 const sendSuccess = await this.trySendBatches(batches);
                 if (sendSuccess) {
-                    this.queue.clear();
+                    this.queuedInsightsByProfile.clear();
                     this.flushRuntime.handleFlushSuccess();
                 } else this.flushRuntime.handleFlushFailure({
                     queuedBatches: batches.length,
@@ -963,30 +1162,12 @@ var __webpack_exports__ = {};
                 });
             } finally{
                 this.flushRuntime.markFlushFinished();
+                this.reconcilePeriodicFlushTimer();
             }
         }
-        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
-                });
-            });
-        }
         createBatches() {
             const batches = [];
-            this.queue.forEach(({ profile, events })=>{
+            this.queuedInsightsByProfile.forEach(({ profile, events })=>{
                 batches.push({
                     profile,
                     events
@@ -996,998 +1177,407 @@ var __webpack_exports__ = {};
         }
         async trySendBatches(batches) {
             try {
-                return await this.api.insights.sendBatchEvents(batches);
+                return await this.insightsApi.sendBatchEvents(batches);
             } catch (error) {
-                AnalyticsStateful_logger.warn('Analytics queue flush request threw an error', error);
+                InsightsQueue_coreLogger.warn('Insights queue flush request threw an error', error);
                 return false;
             }
         }
         getQueuedEventCount() {
             let queuedCount = 0;
-            this.queue.forEach(({ events })=>{
+            this.queuedInsightsByProfile.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);
+        ensurePeriodicFlushTimer() {
+            if (void 0 !== this.insightsPeriodicFlushTimer) return;
+            if (0 === this.getQueuedEventCount()) return;
+            this.insightsPeriodicFlushTimer = setInterval(()=>{
+                this.flush();
+            }, this.flushIntervalMs);
+        }
+        reconcilePeriodicFlushTimer() {
+            if (this.getQueuedEventCount() > 0) return void this.ensurePeriodicFlushTimer();
+            this.clearPeriodicFlushTimer();
         }
     }
-    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
-                }
-            });
-        }
-        get flagsResolver() {
-            return this._personalization.flagsResolver;
-        }
-        get mergeTagValueResolver() {
-            return this._personalization.mergeTagValueResolver;
-        }
-        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
+    var symbols = __webpack_require__("./src/symbols.ts");
+    const CoreStateful_coreLogger = (0, logger_namespaceObject.createScopedLogger)('CoreStateful');
+    const DEFAULT_ALLOWED_EVENT_TYPES = [
+        'identify',
+        'page',
+        'screen'
+    ];
+    const OFFLINE_QUEUE_MAX_EVENTS = 100;
+    const hasDefinedValues = (record)=>Object.values(record).some((value)=>void 0 !== value);
+    const createStatefulExperienceApiConfig = (api)=>{
+        if (void 0 === api) return;
+        const experienceConfig = {
+            baseUrl: api.experienceBaseUrl,
+            enabledFeatures: api.enabledFeatures,
+            ip: api.ip,
+            locale: api.locale,
+            plainText: api.plainText,
+            preflight: api.preflight
         };
-        return singletonGlobal[STATEFUL_RUNTIME_LOCK_KEY];
+        return hasDefinedValues(experienceConfig) ? experienceConfig : void 0;
     };
-    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;
-                };
-            }
-            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);
-                };
-            }
-            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);
-                }
-            }
-            if (0 === kind || 1 === kind) {
-                if (void 0 === init) init = function(instance, init) {
-                    return init;
-                };
-                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);
-                    });
-                } 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);
-                }
-            }
-            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;
-                    }
-                }
-                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);
-                }
-            };
+    const createStatefulInsightsApiConfig = (api)=>{
+        if (void 0 === api) return;
+        const insightsConfig = {
+            baseUrl: api.insightsBaseUrl,
+            beaconHandler: api.beaconHandler
         };
-    }
-    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)
+        return hasDefinedValues(insightsConfig) ? insightsConfig : void 0;
+    };
+    const resolveQueuePolicy = (policy)=>({
+            flush: resolveQueueFlushPolicy(policy?.flush),
+            offlineMaxEvents: toPositiveInt(policy?.offlineMaxEvents, OFFLINE_QUEUE_MAX_EVENTS),
+            onOfflineDrop: policy?.onOfflineDrop
         });
-    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;
+    let statefulInstanceCounter = 0;
+    class CoreStateful extends src_CoreStatefulEventEmitter {
+        singletonOwner;
+        destroyed = false;
+        allowedEventTypes;
+        experienceQueue;
+        insightsQueue;
+        onEventBlocked;
         states = {
             blockedEventStream: toObservable(blockedEvent),
+            flag: (name)=>this.getFlagObservable(name),
+            consent: toObservable(consent),
             eventStream: toObservable(signals_event),
-            flags: toObservable(flags),
-            profile: toObservable(signals_profile),
-            personalizations: toObservable(signals_personalizations)
+            canOptimize: toObservable(canOptimize),
+            selectedOptimizations: toObservable(signals_selectedOptimizations),
+            previewPanelAttached: toObservable(previewPanelAttached),
+            previewPanelOpen: toObservable(previewPanelOpen),
+            profile: toObservable(signals_profile)
         };
-        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);
-                }
+        constructor(config){
+            super(config, {
+                experience: createStatefulExperienceApiConfig(config.api),
+                insights: createStatefulInsightsApiConfig(config.api)
             });
-            if (defaults) {
-                const { changes: defaultChanges, personalizations: defaultPersonalizations, profile: defaultProfile } = defaults;
+            this.singletonOwner = `CoreStateful#${++statefulInstanceCounter}`;
+            acquireStatefulRuntimeSingleton(this.singletonOwner);
+            try {
+                const { allowedEventTypes, defaults, getAnonymousId, onEventBlocked, queuePolicy } = config;
+                const { changes: defaultChanges, consent: defaultConsent, selectedOptimizations: defaultSelectedOptimizations, profile: defaultProfile } = defaults ?? {};
+                const resolvedQueuePolicy = resolveQueuePolicy(queuePolicy);
+                this.allowedEventTypes = allowedEventTypes ?? DEFAULT_ALLOWED_EVENT_TYPES;
+                this.onEventBlocked = onEventBlocked;
+                this.insightsQueue = new InsightsQueue({
+                    eventInterceptors: this.interceptors.event,
+                    flushPolicy: resolvedQueuePolicy.flush,
+                    insightsApi: this.api.insights
+                });
+                this.experienceQueue = new ExperienceQueue({
+                    experienceApi: this.api.experience,
+                    eventInterceptors: this.interceptors.event,
+                    flushPolicy: resolvedQueuePolicy.flush,
+                    getAnonymousId: getAnonymousId ?? (()=>void 0),
+                    offlineMaxEvents: resolvedQueuePolicy.offlineMaxEvents,
+                    onOfflineDrop: resolvedQueuePolicy.onOfflineDrop,
+                    stateInterceptors: this.interceptors.state
+                });
+                if (void 0 !== defaultConsent) consent.value = defaultConsent;
                 (0, signals_core_namespaceObject.batch)(()=>{
-                    signals_changes.value = defaultChanges;
-                    signals_personalizations.value = defaultPersonalizations;
-                    signals_profile.value = defaultProfile;
+                    if (void 0 !== defaultChanges) signals_changes.value = defaultChanges;
+                    if (void 0 !== defaultSelectedOptimizations) signals_selectedOptimizations.value = defaultSelectedOptimizations;
+                    if (void 0 !== defaultProfile) signals_profile.value = defaultProfile;
                 });
+                this.initializeEffects();
+            } catch (error) {
+                releaseStatefulRuntimeSingleton(this.singletonOwner);
+                throw error;
             }
-            if (defaults?.consent !== void 0) {
-                const { consent: defaultConsent } = defaults;
-                consent.value = defaultConsent;
-            }
-            this.getAnonymousId = getAnonymousId ?? (()=>void 0);
+        }
+        initializeEffects() {
             (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'}`);
+                CoreStateful_coreLogger.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'}`);
+                CoreStateful_coreLogger.debug(`Variants have been ${signals_selectedOptimizations.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})`);
+                CoreStateful_coreLogger.info(`Core ${consent.value ? 'will' : 'will not'} emit gated events due to consent (${consent.value})`);
             });
             (0, signals_core_namespaceObject.effect)(()=>{
                 if (!online.value) return;
-                this.flushRuntime.clearScheduledRetry();
-                this.flush({
+                this.insightsQueue.clearScheduledRetry();
+                this.experienceQueue.clearScheduledRetry();
+                this.flushQueues({
                     force: true
                 });
             });
         }
+        async flushQueues(options = {}) {
+            await this.insightsQueue.flush(options);
+            await this.experienceQueue.flush(options);
+        }
+        destroy() {
+            if (this.destroyed) return;
+            this.destroyed = true;
+            this.insightsQueue.flush({
+                force: true
+            }).catch((error)=>{
+                logger_namespaceObject.logger.warn('Failed to flush insights queue during destroy()', String(error));
+            });
+            this.experienceQueue.flush({
+                force: true
+            }).catch((error)=>{
+                logger_namespaceObject.logger.warn('Failed to flush Experience queue during destroy()', String(error));
+            });
+            this.insightsQueue.clearPeriodicFlushTimer();
+            releaseStatefulRuntimeSingleton(this.singletonOwner);
+        }
         reset() {
-            this.flushRuntime.reset();
             (0, signals_core_namespaceObject.batch)(()=>{
-                signals_changes.value = void 0;
                 blockedEvent.value = void 0;
                 signals_event.value = void 0;
+                signals_changes.value = void 0;
                 signals_profile.value = void 0;
-                signals_personalizations.value = void 0;
+                signals_selectedOptimizations.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 flush() {
+            await this.flushQueues();
         }
-        async screen(payload) {
-            PersonalizationStateful_logger.info(`Sending "screen" event for "${payload.name}"`);
-            const event = this.builder.buildScreenView(payload);
-            return await this.sendOrEnqueueEvent(event);
+        consent(accept) {
+            consent.value = accept;
         }
-        async track(payload) {
-            PersonalizationStateful_logger.info(`Sending "track" event "${payload.event}"`);
-            const event = this.builder.buildTrack(payload);
-            return await this.sendOrEnqueueEvent(event);
+        get online() {
+            return online.value ?? false;
         }
-        async trackComponentView(payload) {
-            PersonalizationStateful_logger.info(`Sending "track personalization" event for ${payload.componentId}`);
-            const event = this.builder.buildComponentView(payload);
-            return await this.sendOrEnqueueEvent(event);
+        set online(isOnline) {
+            online.value = isOnline;
         }
-        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);
+        registerPreviewPanel(previewPanel) {
+            Reflect.set(previewPanel, symbols.PREVIEW_PANEL_SIGNALS_SYMBOL, signals);
+            Reflect.set(previewPanel, symbols.PREVIEW_PANEL_SIGNAL_FNS_SYMBOL, signalFns);
         }
-        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
+    }
+    const src_CoreStateful = CoreStateful;
+    var api_schemas = __webpack_require__("./src/api-schemas.ts");
+    const TRACK_CLICK_PROFILE_ERROR = 'CoreStateless.trackClick() requires `payload.profile.id` for Insights delivery.';
+    const TRACK_HOVER_PROFILE_ERROR = 'CoreStateless.trackHover() requires `payload.profile.id` for Insights delivery.';
+    const TRACK_FLAG_VIEW_PROFILE_ERROR = 'CoreStateless.trackFlagView() requires `payload.profile.id` for Insights delivery.';
+    const NON_STICKY_TRACK_VIEW_PROFILE_ERROR = 'CoreStateless.trackView() requires `payload.profile.id` when `payload.sticky` is not `true`.';
+    const STICKY_TRACK_VIEW_PROFILE_ERROR = 'CoreStateless.trackView() could not derive a profile from the sticky Experience response. Pass `payload.profile.id` explicitly if you need a fallback.';
+    const CoreStateless_hasDefinedValues = (record)=>Object.values(record).some((value)=>void 0 !== value);
+    const requireInsightsProfile = (profile, errorMessage)=>{
+        if (void 0 !== profile) return profile;
+        throw new Error(errorMessage);
+    };
+    const createStatelessExperienceApiConfig = (api)=>{
+        if (void 0 === api) return;
+        const experienceConfig = {
+            baseUrl: api.experienceBaseUrl,
+            enabledFeatures: api.enabledFeatures
+        };
+        return CoreStateless_hasDefinedValues(experienceConfig) ? experienceConfig : void 0;
+    };
+    const createStatelessInsightsApiConfig = (api)=>{
+        if (api?.insightsBaseUrl === void 0) return;
+        return {
+            baseUrl: api.insightsBaseUrl
+        };
+    };
+    class CoreStateless extends src_CoreBase {
+        constructor(config){
+            super(config, {
+                experience: createStatelessExperienceApiConfig(config.api),
+                insights: createStatelessInsightsApiConfig(config.api)
             });
         }
-        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 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
-                });
-            } finally{
-                this.flushRuntime.markFlushFinished();
-            }
-        }
-        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 identify(payload, requestOptions) {
+            const { profile, ...builderArgs } = payload;
+            return await this.sendExperienceEvent(this.eventBuilder.buildIdentify(builderArgs), profile, requestOptions);
         }
-        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 page(payload = {}, requestOptions) {
+            const { profile, ...builderArgs } = payload;
+            return await this.sendExperienceEvent(this.eventBuilder.buildPageView(builderArgs), profile, requestOptions);
         }
-        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;
-            });
+        async screen(payload, requestOptions) {
+            const { profile, ...builderArgs } = payload;
+            return await this.sendExperienceEvent(this.eventBuilder.buildScreenView(builderArgs), profile, requestOptions);
         }
-    }
-    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');
+        async track(payload, requestOptions) {
             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);
+            return await this.sendExperienceEvent(this.eventBuilder.buildTrack(builderArgs), profile, requestOptions);
         }
-        async page(payload) {
-            PersonalizationStateless_logger.info('Sending "page" event');
+        async trackView(payload, requestOptions) {
             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);
+            let result;
+            let insightsProfile = profile;
+            if (payload.sticky) {
+                result = await this.sendExperienceEvent(this.eventBuilder.buildView(builderArgs), profile, requestOptions);
+                const { profile: responseProfile } = result;
+                insightsProfile = responseProfile;
+            }
+            await this.sendInsightsEvent(this.eventBuilder.buildView(builderArgs), requireInsightsProfile(insightsProfile, payload.sticky ? STICKY_TRACK_VIEW_PROFILE_ERROR : NON_STICKY_TRACK_VIEW_PROFILE_ERROR));
+            return result;
         }
-        async screen(payload) {
-            PersonalizationStateless_logger.info(`Sending "screen" event for "${payload.name}"`);
+        async trackClick(payload, _requestOptions) {
             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);
+            await this.sendInsightsEvent(this.eventBuilder.buildClick(builderArgs), requireInsightsProfile(profile, TRACK_CLICK_PROFILE_ERROR));
         }
-        async track(payload) {
-            PersonalizationStateless_logger.info(`Sending "track" event "${payload.event}"`);
+        async trackHover(payload, _requestOptions) {
             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);
+            await this.sendInsightsEvent(this.eventBuilder.buildHover(builderArgs), requireInsightsProfile(profile, TRACK_HOVER_PROFILE_ERROR));
         }
-        async trackComponentView(payload) {
-            PersonalizationStateless_logger.info('Sending "track personalization" event');
+        async trackFlagView(payload, _requestOptions) {
             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);
+            await this.sendInsightsEvent(this.eventBuilder.buildFlagView(builderArgs), requireInsightsProfile(profile, TRACK_FLAG_VIEW_PROFILE_ERROR));
         }
-        async upsertProfile(event, profile) {
+        async sendExperienceEvent(event, profile, requestOptions) {
             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({
+            const validEvent = (0, api_schemas_.parseWithFriendlyError)(api_schemas_.ExperienceEvent, intercepted);
+            return await this.api.experience.upsertProfile({
                 profileId: profile?.id,
                 events: [
                     validEvent
                 ]
-            });
-            return data;
+            }, requestOptions);
         }
-    }
-    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 { queuePolicy, ...apiConfig } = config;
-        const resolvedApiConfig = Object.keys(apiConfig).length > 0 ? apiConfig : void 0;
-        return {
-            apiConfig: resolvedApiConfig,
-            queuePolicy
-        };
-    };
-    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
-            };
-            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;
+        async sendInsightsEvent(event, profile) {
+            const intercepted = await this.interceptors.event.run(event);
+            const validEvent = (0, api_schemas_.parseWithFriendlyError)(api_schemas_.InsightsEvent, intercepted);
+            const batchEvent = (0, api_schemas_.parseWithFriendlyError)(api_schemas_.BatchInsightsEventArray, [
+                {
+                    profile: (0, api_schemas_.parseWithFriendlyError)(api_schemas.PartialProfile, profile),
+                    events: [
+                        validEvent
+                    ]
                 }
-                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;
-            }
-        }
-        destroy() {
-            if (this.destroyed) return;
-            this.destroyed = true;
-            releaseStatefulRuntimeSingleton(this.singletonOwner);
-        }
-        get states() {
-            return {
-                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)
-            };
-        }
-        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);
+            ]);
+            await this.api.insights.sendBatchEvents(batchEvent);
         }
     }
-    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;
+    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 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.CHANGES_CACHE_KEY = __webpack_exports__.CHANGES_CACHE_KEY;
 exports.CONSENT_KEY = __webpack_exports__.CONSENT_KEY;
+exports.ClickBuilderArgs = __webpack_exports__.ClickBuilderArgs;
 exports.CoreStateful = __webpack_exports__.CoreStateful;
 exports.CoreStateless = __webpack_exports__.CoreStateless;
 exports.DEBUG_FLAG_KEY = __webpack_exports__.DEBUG_FLAG_KEY;
+exports.DEFAULT_PAGE_PROPERTIES = __webpack_exports__.DEFAULT_PAGE_PROPERTIES;
+exports.EntryInteractionBuilderArgsBase = __webpack_exports__.EntryInteractionBuilderArgsBase;
+exports.EventBuilder = __webpack_exports__.EventBuilder;
+exports.FlagViewBuilderArgs = __webpack_exports__.FlagViewBuilderArgs;
 exports.FlagsResolver = __webpack_exports__.FlagsResolver;
+exports.HoverBuilderArgs = __webpack_exports__.HoverBuilderArgs;
+exports.IdentifyBuilderArgs = __webpack_exports__.IdentifyBuilderArgs;
 exports.InterceptorManager = __webpack_exports__.InterceptorManager;
 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.OptimizedEntryResolver = __webpack_exports__.OptimizedEntryResolver;
 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.PageViewBuilderArgs = __webpack_exports__.PageViewBuilderArgs;
+exports.SELECTED_OPTIMIZATIONS_CACHE_KEY = __webpack_exports__.SELECTED_OPTIMIZATIONS_CACHE_KEY;
+exports.ScreenViewBuilderArgs = __webpack_exports__.ScreenViewBuilderArgs;
+exports.TrackBuilderArgs = __webpack_exports__.TrackBuilderArgs;
+exports.UniversalEventBuilderArgs = __webpack_exports__.UniversalEventBuilderArgs;
+exports.ViewBuilderArgs = __webpack_exports__.ViewBuilderArgs;
 exports.batch = __webpack_exports__.batch;
 exports.effect = __webpack_exports__.effect;
 exports.guardedBy = __webpack_exports__.guardedBy;
 exports.signalFns = __webpack_exports__.signalFns;
 exports.signals = __webpack_exports__.signals;
+exports.toDistinctObservable = __webpack_exports__.toDistinctObservable;
+exports.toObservable = __webpack_exports__.toObservable;
 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",
     "CHANGES_CACHE_KEY",
     "CONSENT_KEY",
+    "ClickBuilderArgs",
     "CoreStateful",
     "CoreStateless",
     "DEBUG_FLAG_KEY",
+    "DEFAULT_PAGE_PROPERTIES",
+    "EntryInteractionBuilderArgsBase",
+    "EventBuilder",
+    "FlagViewBuilderArgs",
     "FlagsResolver",
+    "HoverBuilderArgs",
+    "IdentifyBuilderArgs",
     "InterceptorManager",
     "MergeTagValueResolver",
     "OPTIMIZATION_CORE_SDK_NAME",
     "OPTIMIZATION_CORE_SDK_VERSION",
-    "PERSONALIZATIONS_CACHE_KEY",
+    "OptimizedEntryResolver",
     "PREVIEW_PANEL_SIGNALS_SYMBOL",
     "PREVIEW_PANEL_SIGNAL_FNS_SYMBOL",
     "PROFILE_CACHE_KEY",
-    "PersonalizationBase",
-    "PersonalizationStateful",
-    "PersonalizationStateless",
-    "PersonalizedEntryResolver",
+    "PageViewBuilderArgs",
+    "SELECTED_OPTIMIZATIONS_CACHE_KEY",
+    "ScreenViewBuilderArgs",
+    "TrackBuilderArgs",
+    "UniversalEventBuilderArgs",
+    "ViewBuilderArgs",
     "batch",
     "effect",
     "guardedBy",
     "signalFns",
-    "signals"
+    "signals",
+    "toDistinctObservable",
+    "toObservable"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true