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

package/dist/index.mjs

@@ -1,9 +1,10 @@
-import * as __rspack_external__contentful_optimization_api_client_cba5a7ee from "@contentful/optimization-api-client";
-import { batch, computed, effect, signal } from "@preact/signals-core";
-import { get as compat_get } from "es-toolkit/compat";
-import { diary, enable } from "diary";
-import { compare } from "diary/utils";
-import { isEqual } from "es-toolkit";
+import { batch, computed, effect, signal, untracked } from "@preact/signals-core";
+import { isEqual } from "es-toolkit/predicate";
+import { __rspack_external__contentful_optimization_api_client_api_schemas_4192893e } from "./808.mjs";
+import { __rspack_external__contentful_optimization_api_client_logger_f0d05f82 } from "./499.mjs";
+import { __rspack_external__contentful_optimization_api_client_cba5a7ee } from "./942.mjs";
+import { OPTIMIZATION_CORE_SDK_NAME, OPTIMIZATION_CORE_SDK_VERSION } from "./260.mjs";
+import { PREVIEW_PANEL_SIGNALS_SYMBOL, PREVIEW_PANEL_SIGNAL_FNS_SYMBOL } from "./632.mjs";
 const FlagsResolver = {
     resolve (changes) {
         if (!changes) return {};
@@ -15,126 +16,20 @@ const FlagsResolver = {
     }
 };
 const resolvers_FlagsResolver = FlagsResolver;
-class Logger {
-    name = '@contentful/optimization';
-    PREFIX_PARTS = [
-        'Ctfl',
-        'O10n'
-    ];
-    DELIMITER = ':';
-    diary;
-    sinks = [];
-    constructor(){
-        this.diary = diary(this.name, this.onLogEvent.bind(this));
-        enable(this.name);
-    }
-    assembleLocationPrefix(logLocation) {
-        return `[${[
-            ...this.PREFIX_PARTS,
-            logLocation
-        ].join(this.DELIMITER)}]`;
-    }
-    addSink(sink) {
-        this.sinks = [
-            ...this.sinks.filter((existingSink)=>existingSink.name !== sink.name),
-            sink
-        ];
-    }
-    removeSink(name) {
-        this.sinks = this.sinks.filter((sink)=>sink.name !== name);
-    }
-    removeSinks() {
-        this.sinks = [];
-    }
-    debug(logLocation, message, ...args) {
-        this.diary.debug(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-    }
-    info(logLocation, message, ...args) {
-        this.diary.info(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-    }
-    log(logLocation, message, ...args) {
-        this.diary.log(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-    }
-    warn(logLocation, message, ...args) {
-        this.diary.warn(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-    }
-    error(logLocation, message, ...args) {
-        this.diary.error(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-    }
-    fatal(logLocation, message, ...args) {
-        this.diary.fatal(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
-    }
-    onLogEvent(event) {
-        this.sinks.forEach((sink)=>{
-            sink.ingest(event);
-        });
-    }
-}
-const logger = new Logger();
-function createScopedLogger(location) {
-    return {
-        debug: (message, ...args)=>{
-            logger.debug(location, message, ...args);
-        },
-        info: (message, ...args)=>{
-            logger.info(location, message, ...args);
-        },
-        log: (message, ...args)=>{
-            logger.log(location, message, ...args);
-        },
-        warn: (message, ...args)=>{
-            logger.warn(location, message, ...args);
-        },
-        error: (message, ...args)=>{
-            logger.error(location, message, ...args);
-        },
-        fatal: (message, ...args)=>{
-            logger.fatal(location, message, ...args);
-        }
-    };
-}
-class LogSink {
-}
-const src_LogSink = LogSink;
-const consoleMap = {
-    debug: (...args)=>{
-        console.debug(...args);
-    },
-    info: (...args)=>{
-        console.info(...args);
-    },
-    log: (...args)=>{
-        console.log(...args);
-    },
-    warn: (...args)=>{
-        console.warn(...args);
-    },
-    error: (...args)=>{
-        console.error(...args);
-    },
-    fatal: (...args)=>{
-        console.error(...args);
-    }
-};
-const COMPARISON_EQUALITY = 0;
-class ConsoleLogSink extends src_LogSink {
-    name = 'ConsoleLogSink';
-    verbosity;
-    constructor(verbosity){
-        super();
-        this.verbosity = verbosity ?? 'error';
-    }
-    ingest(event) {
-        if (compare(this.verbosity, event.level) > COMPARISON_EQUALITY) return;
-        consoleMap[event.level](...event.messages);
-    }
-}
-const MergeTagValueResolver_logger = createScopedLogger('Personalization');
+const logger = (0, __rspack_external__contentful_optimization_api_client_logger_f0d05f82.createScopedLogger)('Personalization');
 const RESOLUTION_WARNING_BASE = 'Could not resolve Merge Tag value:';
+const getAtPath = (value, path)=>{
+    if (!value || 'object' != typeof value) return;
+    if (!path) return value;
+    let current = value;
+    const segments = path.split('.').filter(Boolean);
+    for (const segment of segments){
+        if (!current || 'object' != typeof current && 'function' != typeof current) return;
+        current = Reflect.get(current, segment);
+    }
+    return current;
+};
 const MergeTagValueResolver = {
-    isMergeTagEntry (embeddedEntryNodeTarget) {
-        return __rspack_external__contentful_optimization_api_client_cba5a7ee.MergeTagEntry.safeParse(embeddedEntryNodeTarget).success;
-    },
     normalizeSelectors (id) {
         return id.split('_').map((_path, index, paths)=>{
             const dotPath = paths.slice(0, index).join('.');
@@ -147,46 +42,46 @@ const MergeTagValueResolver = {
     },
     getValueFromProfile (id, profile) {
         const selectors = MergeTagValueResolver.normalizeSelectors(id);
-        const matchingSelector = selectors.find((selector)=>compat_get(profile, selector));
+        const matchingSelector = selectors.find((selector)=>getAtPath(profile, selector));
         if (!matchingSelector) return;
-        const value = compat_get(profile, matchingSelector);
+        const value = getAtPath(profile, matchingSelector);
         if (!value || 'string' != typeof value && 'number' != typeof value && 'boolean' != typeof value) return;
         return `${value}`;
     },
     resolve (mergeTagEntry, profile) {
-        if (!MergeTagValueResolver.isMergeTagEntry(mergeTagEntry)) return void MergeTagValueResolver_logger.warn(`${RESOLUTION_WARNING_BASE} supplied entry is not a Merge Tag entry`);
+        if (!(0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isMergeTagEntry)(mergeTagEntry)) return void logger.warn(`${RESOLUTION_WARNING_BASE} supplied entry is not a Merge Tag entry`);
         const { fields: { nt_fallback: fallback } } = mergeTagEntry;
-        if (!__rspack_external__contentful_optimization_api_client_cba5a7ee.Profile.safeParse(profile).success) {
-            MergeTagValueResolver_logger.warn(`${RESOLUTION_WARNING_BASE} no valid profile`);
+        if (!__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.Profile.safeParse(profile).success) {
+            logger.warn(`${RESOLUTION_WARNING_BASE} no valid profile`);
             return fallback;
         }
         return MergeTagValueResolver.getValueFromProfile(mergeTagEntry.fields.nt_mergetag_id, profile) ?? fallback;
     }
 };
 const resolvers_MergeTagValueResolver = MergeTagValueResolver;
-const PersonalizedEntryResolver_logger = createScopedLogger('Personalization');
+const PersonalizedEntryResolver_logger = (0, __rspack_external__contentful_optimization_api_client_logger_f0d05f82.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, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizedEntry)(personalizedEntry))) return;
-        const personalizationEntry = personalizedEntry.fields.nt_experiences.filter((maybePersonalization)=>(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizationEntry)(maybePersonalization)).find((personalizationEntry)=>selectedPersonalizations.some(({ experienceId })=>experienceId === personalizationEntry.fields.nt_experience_id));
+        if (!skipValidation && (!selectedPersonalizations.length || !(0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isPersonalizedEntry)(personalizedEntry))) return;
+        const personalizationEntry = personalizedEntry.fields.nt_experiences.filter((maybePersonalization)=>(0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isPersonalizationEntry)(maybePersonalization)).find((personalizationEntry)=>selectedPersonalizations.some(({ experienceId })=>experienceId === personalizationEntry.fields.nt_experience_id));
         return personalizationEntry;
     },
     getSelectedPersonalization ({ personalizationEntry, selectedPersonalizations }, skipValidation = false) {
-        if (!skipValidation && (!selectedPersonalizations.length || !(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizationEntry)(personalizationEntry))) return;
+        if (!skipValidation && (!selectedPersonalizations.length || !(0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isPersonalizationEntry)(personalizationEntry))) return;
         const selectedPersonalization = selectedPersonalizations.find(({ experienceId })=>experienceId === personalizationEntry.fields.nt_experience_id);
         return selectedPersonalization;
     },
     getSelectedVariant ({ personalizedEntry, personalizationEntry, selectedVariantIndex }, skipValidation = false) {
-        if (!skipValidation && (!(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizedEntry)(personalizedEntry) || !(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizationEntry)(personalizationEntry))) return;
-        const relevantVariants = personalizationEntry.fields.nt_config?.components?.filter((component)=>(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isEntryReplacementComponent)(component) && !component.baseline.hidden).find((component)=>component.baseline.id === personalizedEntry.sys.id)?.variants;
+        if (!skipValidation && (!(0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isPersonalizedEntry)(personalizedEntry) || !(0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isPersonalizationEntry)(personalizationEntry))) return;
+        const relevantVariants = personalizationEntry.fields.nt_config?.components?.filter((component)=>(0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isEntryReplacementComponent)(component) && !component.baseline.hidden).find((component)=>component.baseline.id === personalizedEntry.sys.id)?.variants;
         if (!relevantVariants?.length) return;
         return relevantVariants.at(selectedVariantIndex - 1);
     },
     getSelectedVariantEntry ({ personalizationEntry, selectedVariant }, skipValidation = false) {
-        if (!skipValidation && (!(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizationEntry)(personalizationEntry) || !(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isEntryReplacementVariant)(selectedVariant))) return;
+        if (!skipValidation && (!(0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isPersonalizationEntry)(personalizationEntry) || !(0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isEntryReplacementVariant)(selectedVariant))) return;
         const selectedVariantEntry = personalizationEntry.fields.nt_variants?.find((variant)=>variant.sys.id === selectedVariant.id);
-        return (0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isEntry)(selectedVariantEntry) ? selectedVariantEntry : void 0;
+        return (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isEntry)(selectedVariantEntry) ? selectedVariantEntry : void 0;
     },
     resolve (entry, selectedPersonalizations) {
         PersonalizedEntryResolver_logger.debug(`Resolving personalized entry for baseline entry ${entry.sys.id}`);
@@ -196,7 +91,7 @@ const PersonalizedEntryResolver = {
                 entry
             };
         }
-        if (!(0, __rspack_external__contentful_optimization_api_client_cba5a7ee.isPersonalizedEntry)(entry)) {
+        if (!(0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.isPersonalizedEntry)(entry)) {
             PersonalizedEntryResolver_logger.warn(`${PersonalizedEntryResolver_RESOLUTION_WARNING_BASE} entry ${entry.sys.id} is not personalized`);
             return {
                 entry
@@ -253,10 +148,13 @@ const PersonalizedEntryResolver = {
 };
 const resolvers_PersonalizedEntryResolver = PersonalizedEntryResolver;
 const signals_changes = signal();
+const blockedEvent = signal();
 const consent = signal();
 const signals_event = signal();
 const flags = computed(()=>resolvers_FlagsResolver.resolve(signals_changes.value ?? []));
 const online = signal(true);
+const previewPanelAttached = signal(false);
+const previewPanelOpen = signal(false);
 const signals_personalizations = signal();
 const signals_profile = signal();
 function toObservable(s) {
@@ -272,14 +170,23 @@ function toObservable(s) {
     };
 }
 const signals = {
+    blockedEvent: blockedEvent,
     changes: signals_changes,
     consent: consent,
     event: signals_event,
     flags: flags,
     online: online,
+    previewPanelAttached: previewPanelAttached,
+    previewPanelOpen: previewPanelOpen,
     personalizations: signals_personalizations,
     profile: signals_profile
 };
+const signalFns = {
+    batch: batch,
+    computed: computed,
+    effect: effect,
+    untracked: untracked
+};
 const isFunction = (v)=>'function' == typeof v;
 const nameToString = (name)=>'string' == typeof name ? name : 'symbol' == typeof name ? name.description ?? String(name) : String(name);
 const isOnBlockedKey = (v)=>'string' == typeof v || 'symbol' == typeof v;
@@ -323,49 +230,195 @@ function guardedBy(predicateName, opts) {
         });
     };
 }
-class ValuePresence {
-    #map;
-    constructor(defaultMap){
-        const map = new Map();
-        if (defaultMap) Object.entries(defaultMap).map(([scope, values])=>map.set(scope.length ? scope : void 0, new Set(values)));
-        this.#map = map;
-    }
-    isPresent(scope, value) {
-        return this.#map.get(scope)?.has(value) ?? false;
-    }
-    addValue(scope, value) {
-        const values = this.#map.get(scope);
-        if (values) values.add(value);
-        else this.#map.set(scope, new Set([
-            value
-        ]));
-    }
-    removeValue(scope, value) {
-        this.#map.get(scope)?.delete(value);
-    }
-    reset(scope) {
-        if (void 0 !== scope) this.#map.get(scope)?.clear();
-        else this.#map.clear();
+const toPositiveInt = (value, fallback)=>{
+    if (!Number.isFinite(value) || void 0 === value || value < 1) return fallback;
+    return Math.floor(value);
+};
+const toRatio = (value, fallback)=>{
+    if (!Number.isFinite(value) || void 0 === value) return fallback;
+    return Math.min(1, Math.max(0, value));
+};
+const DEFAULT_QUEUE_FLUSH_POLICY = {
+    baseBackoffMs: 500,
+    maxBackoffMs: 30000,
+    jitterRatio: 0.2,
+    maxConsecutiveFailures: 8,
+    circuitOpenMs: 120000
+};
+const resolveQueueFlushPolicy = (policy, defaults = DEFAULT_QUEUE_FLUSH_POLICY)=>{
+    const baseBackoffMs = toPositiveInt(policy?.baseBackoffMs, defaults.baseBackoffMs);
+    const maxBackoffMs = Math.max(baseBackoffMs, toPositiveInt(policy?.maxBackoffMs, defaults.maxBackoffMs));
+    return {
+        baseBackoffMs,
+        maxBackoffMs,
+        jitterRatio: toRatio(policy?.jitterRatio, defaults.jitterRatio),
+        maxConsecutiveFailures: toPositiveInt(policy?.maxConsecutiveFailures, defaults.maxConsecutiveFailures),
+        circuitOpenMs: toPositiveInt(policy?.circuitOpenMs, defaults.circuitOpenMs),
+        onCircuitOpen: policy?.onCircuitOpen,
+        onFlushFailure: policy?.onFlushFailure,
+        onFlushRecovered: policy?.onFlushRecovered
+    };
+};
+const computeQueueFlushRetryDelayMs = (options)=>{
+    const { consecutiveFailures, policy: { baseBackoffMs, jitterRatio, maxBackoffMs } } = options;
+    const exponential = baseBackoffMs * 2 ** Math.max(0, consecutiveFailures - 1);
+    const capped = Math.min(maxBackoffMs, exponential);
+    const jitter = capped * jitterRatio * Math.random();
+    return Math.round(capped + jitter);
+};
+const createQueueFlushFailureWindow = (options)=>{
+    const { consecutiveFailures, failureTimestamp, retryDelayMs, policy: { maxConsecutiveFailures, circuitOpenMs } } = options;
+    if (consecutiveFailures < maxConsecutiveFailures) return {
+        openedCircuit: false,
+        retryDelayMs,
+        nextFlushAllowedAt: failureTimestamp + retryDelayMs,
+        circuitOpenUntil: 0
+    };
+    const circuitOpenUntil = failureTimestamp + circuitOpenMs;
+    return {
+        openedCircuit: true,
+        retryDelayMs: circuitOpenMs,
+        nextFlushAllowedAt: circuitOpenUntil,
+        circuitOpenUntil
+    };
+};
+class QueueFlushRuntime {
+    circuitOpenUntil = 0;
+    flushFailureCount = 0;
+    flushInFlight = false;
+    nextFlushAllowedAt = 0;
+    onCallbackError;
+    onRetry;
+    policy;
+    retryTimer;
+    constructor(options){
+        const { onCallbackError, onRetry, policy } = options;
+        this.policy = policy;
+        this.onRetry = onRetry;
+        this.onCallbackError = onCallbackError;
+    }
+    reset() {
+        this.clearScheduledRetry();
+        this.circuitOpenUntil = 0;
+        this.flushFailureCount = 0;
+        this.flushInFlight = false;
+        this.nextFlushAllowedAt = 0;
+    }
+    clearScheduledRetry() {
+        if (void 0 === this.retryTimer) return;
+        clearTimeout(this.retryTimer);
+        this.retryTimer = void 0;
+    }
+    shouldSkip(options) {
+        const { force, isOnline } = options;
+        if (this.flushInFlight) return true;
+        if (force) return false;
+        if (!isOnline) return true;
+        const now = Date.now();
+        if (this.nextFlushAllowedAt > now) return true;
+        if (this.circuitOpenUntil > now) return true;
+        return false;
+    }
+    markFlushStarted() {
+        this.flushInFlight = true;
+    }
+    markFlushFinished() {
+        this.flushInFlight = false;
+    }
+    handleFlushSuccess() {
+        const { flushFailureCount: previousConsecutiveFailures } = this;
+        this.clearScheduledRetry();
+        this.circuitOpenUntil = 0;
+        this.flushFailureCount = 0;
+        this.nextFlushAllowedAt = 0;
+        if (previousConsecutiveFailures <= 0) return;
+        this.safeInvoke('onFlushRecovered', {
+            consecutiveFailures: previousConsecutiveFailures
+        });
+    }
+    handleFlushFailure(options) {
+        const { queuedBatches, queuedEvents } = options;
+        this.flushFailureCount += 1;
+        const retryDelayMs = computeQueueFlushRetryDelayMs({
+            consecutiveFailures: this.flushFailureCount,
+            policy: this.policy
+        });
+        const failureTimestamp = Date.now();
+        const failureContext = {
+            consecutiveFailures: this.flushFailureCount,
+            queuedBatches,
+            queuedEvents,
+            retryDelayMs
+        };
+        this.safeInvoke('onFlushFailure', failureContext);
+        const failureWindow = createQueueFlushFailureWindow({
+            consecutiveFailures: this.flushFailureCount,
+            failureTimestamp,
+            retryDelayMs,
+            policy: this.policy
+        });
+        const { circuitOpenUntil, nextFlushAllowedAt, openedCircuit, retryDelayMs: scheduledRetryDelayMs } = failureWindow;
+        this.nextFlushAllowedAt = nextFlushAllowedAt;
+        if (openedCircuit) {
+            this.circuitOpenUntil = circuitOpenUntil;
+            this.safeInvoke('onCircuitOpen', {
+                ...failureContext,
+                retryDelayMs: scheduledRetryDelayMs
+            });
+        }
+        this.scheduleRetry(scheduledRetryDelayMs);
+    }
+    scheduleRetry(delayMs) {
+        this.clearScheduledRetry();
+        this.retryTimer = setTimeout(()=>{
+            this.retryTimer = void 0;
+            this.onRetry();
+        }, delayMs);
+    }
+    safeInvoke(...args) {
+        const [callbackName, payload] = args;
+        try {
+            if ('onFlushRecovered' === callbackName) return void this.policy.onFlushRecovered?.(payload);
+            if ('onCircuitOpen' === callbackName) return void this.policy.onCircuitOpen?.(payload);
+            this.policy.onFlushFailure?.(payload);
+        } catch (error) {
+            this.onCallbackError?.(callbackName, error);
+        }
     }
 }
-const value_presence_ValuePresence = ValuePresence;
+const ProductBase_logger = (0, __rspack_external__contentful_optimization_api_client_logger_f0d05f82.createScopedLogger)('ProductBase');
 const defaultAllowedEvents = [
+    'identify',
     'page',
-    'identify'
+    'screen'
 ];
 class ProductBase {
     allowedEventTypes;
     builder;
     api;
-    duplicationDetector;
     interceptors;
+    onEventBlocked;
     constructor(options){
         const { api, builder, config, interceptors } = options;
         this.allowedEventTypes = config?.allowedEventTypes ?? defaultAllowedEvents;
         this.api = api;
         this.builder = builder;
-        this.duplicationDetector = new value_presence_ValuePresence(config?.preventedComponentEvents);
         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 src_ProductBase = ProductBase;
@@ -667,14 +720,20 @@ 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 = createScopedLogger('Analytics');
+const AnalyticsStateful_logger = (0, __rspack_external__contentful_optimization_api_client_logger_f0d05f82.createScopedLogger)('Analytics');
 const MAX_QUEUED_EVENTS = 25;
-_dec = guardedBy('isNotDuplicated', {
-    onBlocked: 'onBlockedByDuplication'
+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('isNotDuplicated', {
-    onBlocked: 'onBlockedByDuplication'
+}), _dec2 = guardedBy('hasConsent', {
+    onBlocked: 'onBlockedByConsent'
 }), _dec3 = guardedBy('hasConsent', {
     onBlocked: 'onBlockedByConsent'
 });
@@ -682,25 +741,31 @@ class AnalyticsStateful extends analytics_AnalyticsBase {
     static{
         ({ e: [_initProto] } = _apply_decs_2203_r(this, [
             [
-                [
-                    _dec,
-                    _dec1
-                ],
+                _dec,
                 2,
                 "trackComponentView"
             ],
             [
-                [
-                    _dec2,
-                    _dec3
-                ],
+                _dec1,
+                2,
+                "trackComponentClick"
+            ],
+            [
+                _dec2,
+                2,
+                "trackComponentHover"
+            ],
+            [
+                _dec3,
                 2,
                 "trackFlagView"
             ]
         ], []));
     }
     queue = (_initProto(this), new Map());
+    flushRuntime;
     states = {
+        blockedEventStream: toObservable(blockedEvent),
         eventStream: toObservable(signals_event),
         profile: toObservable(signals_profile)
     };
@@ -712,47 +777,47 @@ class AnalyticsStateful extends analytics_AnalyticsBase {
             config,
             interceptors
         });
-        const { defaults } = config ?? {};
-        if (defaults?.profile !== void 0) {
-            const { profile: defaultProfile } = defaults;
-            signals_profile.value = defaultProfile;
-        }
-        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'}`);
-        });
-        effect(()=>{
-            if (online.value) this.flush();
+        this.applyDefaults(config?.defaults);
+        this.flushRuntime = new QueueFlushRuntime({
+            policy: resolveQueueFlushPolicy(config?.queuePolicy),
+            onRetry: ()=>{
+                this.flush();
+            },
+            onCallbackError: (callbackName, error)=>{
+                AnalyticsStateful_logger.warn(`Analytics flush policy callback "${callbackName}" failed`, error);
+            }
         });
+        this.initializeEffects();
     }
     reset() {
+        this.flushRuntime.reset();
         batch(()=>{
+            blockedEvent.value = void 0;
             signals_event.value = void 0;
             signals_profile.value = void 0;
         });
     }
     hasConsent(name) {
-        return !!consent.value || (this.allowedEventTypes ?? []).includes('trackComponentView' === name || 'trackFlagView' === name ? 'component' : 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);
     }
-    isNotDuplicated(_name, payload) {
-        const [{ componentId: value }, duplicationScope] = payload;
-        const isDuplicated = this.duplicationDetector.isPresent(duplicationScope, value);
-        if (!isDuplicated) this.duplicationDetector.addValue(duplicationScope, value);
-        return !isDuplicated;
-    }
-    onBlockedByDuplication(name, payload) {
-        const componentType = 'trackFlagView' === name ? 'flag' : 'component';
-        AnalyticsStateful_logger.debug(`Duplicate "${componentType} view" event detected, skipping; payload: ${JSON.stringify(payload)}`);
-    }
-    async trackComponentView(payload, _duplicationScope = '') {
+    async trackComponentView(payload) {
         AnalyticsStateful_logger.info(`Processing "component view" event for ${payload.componentId}`);
         await this.enqueueEvent(this.builder.buildComponentView(payload));
     }
-    async trackFlagView(payload, _duplicationScope = '') {
+    async trackComponentClick(payload) {
+        AnalyticsStateful_logger.info(`Processing "component click" event for ${payload.componentId}`);
+        await this.enqueueEvent(this.builder.buildComponentClick(payload));
+    }
+    async trackComponentHover(payload) {
+        AnalyticsStateful_logger.info(`Processing "component hover" event for ${payload.componentId}`);
+        await this.enqueueEvent(this.builder.buildComponentHover(payload));
+    }
+    async trackFlagView(payload) {
         AnalyticsStateful_logger.debug(`Processing "flag view" event for ${payload.componentId}`);
         await this.enqueueEvent(this.builder.buildFlagView(payload));
     }
@@ -760,56 +825,128 @@ class AnalyticsStateful extends analytics_AnalyticsBase {
         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 = __rspack_external__contentful_optimization_api_client_cba5a7ee.InsightsEvent.parse(intercepted);
+        const validEvent = (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.parseWithFriendlyError)(__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.InsightsEvent, intercepted);
         AnalyticsStateful_logger.debug(`Queueing ${validEvent.type} event for profile ${profile.id}`, validEvent);
-        const profileEventQueue = this.queue.get(profile);
+        const { id: profileId } = profile;
+        const queuedProfileEvents = this.queue.get(profileId);
         signals_event.value = validEvent;
-        if (profileEventQueue) profileEventQueue.push(validEvent);
-        else this.queue.set(profile, [
-            validEvent
-        ]);
+        if (queuedProfileEvents) {
+            queuedProfileEvents.profile = profile;
+            queuedProfileEvents.events.push(validEvent);
+        } else this.queue.set(profileId, {
+            profile,
+            events: [
+                validEvent
+            ]
+        });
         await this.flushMaxEvents();
     }
     async flushMaxEvents() {
-        if (this.queue.values().toArray().flat().length >= MAX_QUEUED_EVENTS) await this.flush();
-    }
-    async flush() {
+        if (this.getQueuedEventCount() >= MAX_QUEUED_EVENTS) await this.flush();
+    }
+    async flush(options = {}) {
+        const { force = false } = options;
+        if (this.flushRuntime.shouldSkip({
+            force,
+            isOnline: !!online.value
+        })) return;
         AnalyticsStateful_logger.debug('Flushing event queue');
+        const batches = this.createBatches();
+        if (!batches.length) return void this.flushRuntime.clearScheduledRetry();
+        this.flushRuntime.markFlushStarted();
+        try {
+            const sendSuccess = await this.trySendBatches(batches);
+            if (sendSuccess) {
+                this.queue.clear();
+                this.flushRuntime.handleFlushSuccess();
+            } else this.flushRuntime.handleFlushFailure({
+                queuedBatches: batches.length,
+                queuedEvents: this.getQueuedEventCount()
+            });
+        } finally{
+            this.flushRuntime.markFlushFinished();
+        }
+    }
+    applyDefaults(defaults) {
+        if (defaults?.profile === void 0) return;
+        const { profile: defaultProfile } = defaults;
+        signals_profile.value = defaultProfile;
+    }
+    initializeEffects() {
+        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'}`);
+        });
+        effect(()=>{
+            if (!online.value) return;
+            this.flushRuntime.clearScheduledRetry();
+            this.flush({
+                force: true
+            });
+        });
+    }
+    createBatches() {
         const batches = [];
-        this.queue.forEach((events, profile)=>batches.push({
+        this.queue.forEach(({ profile, events })=>{
+            batches.push({
                 profile,
                 events
-            }));
-        if (!batches.length) return;
-        const sendSuccess = await this.api.insights.sendBatchEvents(batches);
-        if (sendSuccess) this.queue.clear();
+            });
+        });
+        return batches;
+    }
+    async trySendBatches(batches) {
+        try {
+            return await this.api.insights.sendBatchEvents(batches);
+        } catch (error) {
+            AnalyticsStateful_logger.warn('Analytics queue flush request threw an error', error);
+            return false;
+        }
+    }
+    getQueuedEventCount() {
+        let queuedCount = 0;
+        this.queue.forEach(({ events })=>{
+            queuedCount += events.length;
+        });
+        return queuedCount;
     }
 }
 const analytics_AnalyticsStateful = AnalyticsStateful;
-const AnalyticsStateless_logger = createScopedLogger('Analytics');
+const AnalyticsStateless_logger = (0, __rspack_external__contentful_optimization_api_client_logger_f0d05f82.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);
-        const intercepted = await this.interceptors.event.run(event);
-        const parsed = __rspack_external__contentful_optimization_api_client_cba5a7ee.ComponentViewEvent.parse(intercepted);
-        await this.sendBatchEvent(parsed, profile);
+        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);
-        const intercepted = await this.interceptors.event.run(event);
-        const parsed = __rspack_external__contentful_optimization_api_client_cba5a7ee.ComponentViewEvent.parse(intercepted);
-        await this.sendBatchEvent(parsed, profile);
+        await this.sendBatchEvent(event, profile);
     }
     async sendBatchEvent(event, profile) {
-        const batchEvent = __rspack_external__contentful_optimization_api_client_cba5a7ee.BatchInsightsEventArray.parse([
+        const intercepted = await this.interceptors.event.run(event);
+        const parsed = (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.parseWithFriendlyError)(__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.InsightsEvent, intercepted);
+        const batchEvent = (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.parseWithFriendlyError)(__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.BatchInsightsEventArray, [
             {
                 profile,
                 events: [
-                    event
+                    parsed
                 ]
             }
         ]);
@@ -817,8 +954,6 @@ class AnalyticsStateless extends analytics_AnalyticsBase {
     }
 }
 const analytics_AnalyticsStateless = AnalyticsStateless;
-const OPTIMIZATION_CORE_SDK_VERSION = "0.1.0-alpha";
-const ANONYMOUS_ID_COOKIE = 'ctfl-opt-aid';
 class InterceptorManager {
     interceptors = new Map();
     nextId = 0;
@@ -854,59 +989,98 @@ class CoreBase {
     };
     constructor(config){
         this.config = config;
-        const { analytics, personalization, eventBuilder, logLevel, environment, clientId } = config;
-        logger.addSink(new ConsoleLogSink(logLevel));
+        const { analytics, personalization, eventBuilder, logLevel, environment, clientId, fetchOptions } = config;
+        __rspack_external__contentful_optimization_api_client_logger_f0d05f82.logger.addSink(new __rspack_external__contentful_optimization_api_client_logger_f0d05f82.ConsoleLogSink(logLevel));
         const apiConfig = {
-            ...analytics,
-            ...personalization,
             clientId,
-            environment
+            environment,
+            fetchOptions,
+            analytics,
+            personalization
         };
         this.api = new __rspack_external__contentful_optimization_api_client_cba5a7ee.ApiClient(apiConfig);
         this.eventBuilder = new __rspack_external__contentful_optimization_api_client_cba5a7ee.EventBuilder(eventBuilder ?? {
             channel: 'server',
             library: {
-                name: 'Optimization Core',
+                name: OPTIMIZATION_CORE_SDK_NAME,
                 version: 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);
+        return this._personalization.getCustomFlag(name, changes);
+    }
+    getCustomFlags(changes) {
+        return this._personalization.getCustomFlags(changes);
     }
     personalizeEntry(entry, personalizations) {
-        return this.personalization.personalizeEntry(entry, personalizations);
+        return this._personalization.personalizeEntry(entry, personalizations);
     }
     getMergeTagValue(embeddedEntryNodeTarget, profile) {
-        return this.personalization.getMergeTagValue(embeddedEntryNodeTarget, profile);
+        return this._personalization.getMergeTagValue(embeddedEntryNodeTarget, profile);
     }
     async identify(payload) {
-        return await this.personalization.identify(payload);
+        return await this._personalization.identify(payload);
     }
     async page(payload) {
-        return await this.personalization.page(payload);
+        return await this._personalization.page(payload);
     }
     async screen(payload) {
-        return await this.personalization.screen(payload);
+        return await this._personalization.screen(payload);
     }
     async track(payload) {
-        return await this.personalization.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 trackComponentView(payload, duplicationScope) {
-        if (payload.sticky) return await this.personalization.trackComponentView(payload, duplicationScope);
-        await this.analytics.trackComponentView(payload, duplicationScope);
+    async trackComponentClick(payload) {
+        await this._analytics.trackComponentClick(payload);
     }
-    async trackFlagView(payload, duplicationScope) {
-        await this.analytics.trackFlagView(payload, duplicationScope);
+    async trackComponentHover(payload) {
+        await this._analytics.trackComponentHover(payload);
+    }
+    async trackFlagView(payload) {
+        await this._analytics.trackFlagView(payload);
     }
 }
 const src_CoreBase = CoreBase;
+const STATEFUL_RUNTIME_LOCK_KEY = '__ctfl_optimization_stateful_runtime_lock__';
+const getStatefulRuntimeLock = ()=>{
+    const singletonGlobal = globalThis;
+    singletonGlobal[STATEFUL_RUNTIME_LOCK_KEY] ??= {
+        owner: void 0
+    };
+    return singletonGlobal[STATEFUL_RUNTIME_LOCK_KEY];
+};
+const acquireStatefulRuntimeSingleton = (owner)=>{
+    const lock = getStatefulRuntimeLock();
+    if (lock.owner) throw new Error(`Stateful Optimization SDK already initialized (${lock.owner}). Only one stateful instance is supported per runtime.`);
+    lock.owner = owner;
+};
+const releaseStatefulRuntimeSingleton = (owner)=>{
+    const lock = getStatefulRuntimeLock();
+    if (lock.owner === owner) lock.owner = void 0;
+};
 class PersonalizationBase extends src_ProductBase {
     flagsResolver = resolvers_FlagsResolver;
     mergeTagValueResolver = resolvers_MergeTagValueResolver;
     personalizedEntryResolver = resolvers_PersonalizedEntryResolver;
     getCustomFlag(name, changes) {
-        return resolvers_FlagsResolver.resolve(changes)[name];
+        return this.getCustomFlags(changes)[name];
+    }
+    getCustomFlags(changes) {
+        return resolvers_FlagsResolver.resolve(changes);
     }
     personalizeEntry(entry, personalizations) {
         return resolvers_PersonalizedEntryResolver.resolve(entry, personalizations);
@@ -1210,8 +1384,14 @@ function PersonalizationStateful_applyDecs2203RFactory() {
 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, _dec5, PersonalizationStateful_initProto;
-const PersonalizationStateful_logger = createScopedLogger('Personalization');
+var PersonalizationStateful_dec, PersonalizationStateful_dec1, PersonalizationStateful_dec2, PersonalizationStateful_dec3, _dec4, PersonalizationStateful_initProto;
+const PersonalizationStateful_logger = (0, __rspack_external__contentful_optimization_api_client_logger_f0d05f82.createScopedLogger)('Personalization');
+const OFFLINE_QUEUE_MAX_EVENTS = 100;
+const resolvePersonalizationQueuePolicy = (policy)=>({
+        maxEvents: toPositiveInt(policy?.maxEvents, OFFLINE_QUEUE_MAX_EVENTS),
+        onDrop: policy?.onDrop,
+        flushPolicy: resolveQueueFlushPolicy(policy?.flushPolicy)
+    });
 PersonalizationStateful_dec = guardedBy('hasConsent', {
     onBlocked: 'onBlockedByConsent'
 }), PersonalizationStateful_dec1 = guardedBy('hasConsent', {
@@ -1220,9 +1400,7 @@ PersonalizationStateful_dec = guardedBy('hasConsent', {
     onBlocked: 'onBlockedByConsent'
 }), PersonalizationStateful_dec3 = guardedBy('hasConsent', {
     onBlocked: 'onBlockedByConsent'
-}), _dec4 = guardedBy('isNotDuplicated', {
-    onBlocked: 'onBlockedByDuplication'
-}), _dec5 = guardedBy('hasConsent', {
+}), _dec4 = guardedBy('hasConsent', {
     onBlocked: 'onBlockedByConsent'
 });
 class PersonalizationStateful extends personalization_PersonalizationBase {
@@ -1249,17 +1427,17 @@ class PersonalizationStateful extends personalization_PersonalizationBase {
                 "track"
             ],
             [
-                [
-                    _dec4,
-                    _dec5
-                ],
+                _dec4,
                 2,
                 "trackComponentView"
             ]
         ], []));
     }
     offlineQueue = (PersonalizationStateful_initProto(this), new Set());
+    queuePolicy;
+    flushRuntime;
     states = {
+        blockedEventStream: toObservable(blockedEvent),
         eventStream: toObservable(signals_event),
         flags: toObservable(flags),
         profile: toObservable(signals_profile),
@@ -1274,7 +1452,17 @@ class PersonalizationStateful extends personalization_PersonalizationBase {
             config,
             interceptors
         });
-        const { defaults, getAnonymousId } = config ?? {};
+        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);
+            }
+        });
         if (defaults) {
             const { changes: defaultChanges, personalizations: defaultPersonalizations, profile: defaultProfile } = defaults;
             batch(()=>{
@@ -1298,12 +1486,18 @@ class PersonalizationStateful extends personalization_PersonalizationBase {
             PersonalizationStateful_logger.info(`Personalization ${consent.value ? 'will' : 'will not'} take effect due to consent (${consent.value})`);
         });
         effect(()=>{
-            if (online.value) this.flush();
+            if (!online.value) return;
+            this.flushRuntime.clearScheduledRetry();
+            this.flush({
+                force: true
+            });
         });
     }
     reset() {
+        this.flushRuntime.reset();
         batch(()=>{
             signals_changes.value = void 0;
+            blockedEvent.value = void 0;
             signals_event.value = void 0;
             signals_profile.value = void 0;
             signals_personalizations.value = void 0;
@@ -1312,6 +1506,9 @@ class PersonalizationStateful extends personalization_PersonalizationBase {
     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);
     }
@@ -1323,15 +1520,7 @@ class PersonalizationStateful extends personalization_PersonalizationBase {
     }
     onBlockedByConsent(name, payload) {
         PersonalizationStateful_logger.warn(`Event "${name}" was blocked due to lack of consent; payload: ${JSON.stringify(payload)}`);
-    }
-    isNotDuplicated(_name, payload) {
-        const [{ componentId: value }, duplicationScope] = payload;
-        const isDuplicated = this.duplicationDetector.isPresent(duplicationScope, value);
-        if (!isDuplicated) this.duplicationDetector.addValue(duplicationScope, value);
-        return !isDuplicated;
-    }
-    onBlockedByDuplication(_name, payload) {
-        PersonalizationStateful_logger.debug(`Duplicate "component view" event detected, skipping; payload: ${JSON.stringify(payload)}`);
+        this.reportBlockedEvent('consent', 'personalization', name, payload);
     }
     async identify(payload) {
         PersonalizationStateful_logger.info('Sending "identify" event');
@@ -1353,26 +1542,89 @@ class PersonalizationStateful extends personalization_PersonalizationBase {
         const event = this.builder.buildTrack(payload);
         return await this.sendOrEnqueueEvent(event);
     }
-    async trackComponentView(payload, _duplicationScope = '') {
+    async trackComponentView(payload) {
         PersonalizationStateful_logger.info(`Sending "track personalization" event for ${payload.componentId}`);
         const event = this.builder.buildComponentView(payload);
         return await this.sendOrEnqueueEvent(event);
     }
     async sendOrEnqueueEvent(event) {
         const intercepted = await this.interceptors.event.run(event);
-        const validEvent = __rspack_external__contentful_optimization_api_client_cba5a7ee.ExperienceEvent.parse(intercepted);
+        const validEvent = (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.parseWithFriendlyError)(__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.ExperienceEvent, intercepted);
         signals_event.value = validEvent;
         if (online.value) return await this.upsertProfile([
             validEvent
         ]);
         PersonalizationStateful_logger.debug(`Queueing ${validEvent.type} event`, validEvent);
-        this.offlineQueue.add(validEvent);
+        this.enqueueOfflineEvent(validEvent);
+    }
+    enqueueOfflineEvent(event) {
+        let droppedEvents = [];
+        if (this.offlineQueue.size >= this.queuePolicy.maxEvents) {
+            const dropCount = this.offlineQueue.size - this.queuePolicy.maxEvents + 1;
+            droppedEvents = this.dropOldestOfflineEvents(dropCount);
+            if (droppedEvents.length > 0) PersonalizationStateful_logger.warn(`Dropped ${droppedEvents.length} oldest personalization offline event(s) due to queue limit (${this.queuePolicy.maxEvents})`);
+        }
+        this.offlineQueue.add(event);
+        if (droppedEvents.length > 0) this.invokeQueueDropCallback({
+            droppedCount: droppedEvents.length,
+            droppedEvents,
+            maxEvents: this.queuePolicy.maxEvents,
+            queuedEvents: this.offlineQueue.size
+        });
     }
-    async flush() {
-        if (0 === this.offlineQueue.size) return;
+    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');
-        await this.upsertProfile(Array.from(this.offlineQueue));
-        this.offlineQueue.clear();
+        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 upsertProfile(events) {
         const anonymousId = this.getAnonymousId();
@@ -1395,101 +1647,142 @@ class PersonalizationStateful extends personalization_PersonalizationBase {
     }
 }
 const personalization_PersonalizationStateful = PersonalizationStateful;
-const PersonalizationStateless_logger = createScopedLogger('Personalization');
+const PersonalizationStateless_logger = (0, __rspack_external__contentful_optimization_api_client_logger_f0d05f82.createScopedLogger)('Personalization');
 class PersonalizationStateless extends personalization_PersonalizationBase {
     async identify(payload) {
         PersonalizationStateless_logger.info('Sending "identify" event');
         const { profile, ...builderArgs } = payload;
-        const event = __rspack_external__contentful_optimization_api_client_cba5a7ee.IdentifyEvent.parse(this.builder.buildIdentify(builderArgs));
+        const event = (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.parseWithFriendlyError)(__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.IdentifyEvent, this.builder.buildIdentify(builderArgs));
         return await this.upsertProfile(event, profile);
     }
     async page(payload) {
         PersonalizationStateless_logger.info('Sending "page" event');
         const { profile, ...builderArgs } = payload;
-        const event = __rspack_external__contentful_optimization_api_client_cba5a7ee.PageViewEvent.parse(this.builder.buildPageView(builderArgs));
+        const event = (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.parseWithFriendlyError)(__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.PageViewEvent, this.builder.buildPageView(builderArgs));
         return await this.upsertProfile(event, profile);
     }
     async screen(payload) {
         PersonalizationStateless_logger.info(`Sending "screen" event for "${payload.name}"`);
         const { profile, ...builderArgs } = payload;
-        const event = __rspack_external__contentful_optimization_api_client_cba5a7ee.ScreenViewEvent.parse(this.builder.buildScreenView(builderArgs));
+        const event = (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.parseWithFriendlyError)(__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.ScreenViewEvent, this.builder.buildScreenView(builderArgs));
         return await this.upsertProfile(event, profile);
     }
     async track(payload) {
         PersonalizationStateless_logger.info(`Sending "track" event "${payload.event}"`);
         const { profile, ...builderArgs } = payload;
-        const event = __rspack_external__contentful_optimization_api_client_cba5a7ee.TrackEvent.parse(this.builder.buildTrack(builderArgs));
+        const event = (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.parseWithFriendlyError)(__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.TrackEvent, this.builder.buildTrack(builderArgs));
         return await this.upsertProfile(event, profile);
     }
     async trackComponentView(payload) {
         PersonalizationStateless_logger.info('Sending "track personalization" event');
         const { profile, ...builderArgs } = payload;
-        const event = __rspack_external__contentful_optimization_api_client_cba5a7ee.ComponentViewEvent.parse(this.builder.buildComponentView(builderArgs));
+        const event = (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.parseWithFriendlyError)(__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.ComponentViewEvent, this.builder.buildComponentView(builderArgs));
         return await this.upsertProfile(event, profile);
     }
     async upsertProfile(event, profile) {
         const intercepted = await this.interceptors.event.run(event);
+        const validEvent = (0, __rspack_external__contentful_optimization_api_client_api_schemas_4192893e.parseWithFriendlyError)(__rspack_external__contentful_optimization_api_client_api_schemas_4192893e.ExperienceEvent, intercepted);
         const data = await this.api.experience.upsertProfile({
             profileId: profile?.id,
             events: [
-                intercepted
+                validEvent
             ]
         });
         return data;
     }
 }
 const personalization_PersonalizationStateless = PersonalizationStateless;
+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 {
-    analytics;
-    personalization;
+    singletonOwner;
+    destroyed = false;
+    _analytics;
+    _personalization;
     constructor(config){
-        super(config);
-        const { allowedEventTypes, defaults, getAnonymousId, preventedComponentEvents } = config;
-        if (defaults?.consent !== void 0) {
-            const { consent: defaultConsent } = defaults;
-            consent.value = defaultConsent;
+        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;
+            }
+            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;
         }
-        this.analytics = new analytics_AnalyticsStateful({
-            api: this.api,
-            builder: this.eventBuilder,
-            config: {
-                allowedEventTypes,
-                preventedComponentEvents,
-                defaults: {
-                    consent: defaults?.consent,
-                    profile: defaults?.profile
-                }
-            },
-            interceptors: this.interceptors
-        });
-        this.personalization = new personalization_PersonalizationStateful({
-            api: this.api,
-            builder: this.eventBuilder,
-            config: {
-                allowedEventTypes,
-                getAnonymousId,
-                preventedComponentEvents,
-                defaults: {
-                    consent: defaults?.consent,
-                    changes: defaults?.changes,
-                    profile: defaults?.profile,
-                    personalizations: defaults?.personalizations
-                }
-            },
-            interceptors: this.interceptors
-        });
+    }
+    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() {
         batch(()=>{
+            blockedEvent.value = void 0;
             signals_event.value = void 0;
             signals_changes.value = void 0;
             signals_profile.value = void 0;
@@ -1497,31 +1790,35 @@ class CoreStateful extends src_CoreBase {
         });
     }
     async flush() {
-        await this.analytics.flush();
-        await this.personalization.flush();
+        await this._analytics.flush();
+        await this._personalization.flush();
     }
     consent(accept) {
         consent.value = accept;
     }
-    online(isOnline) {
+    get online() {
+        return online.value ?? false;
+    }
+    set online(isOnline) {
         online.value = isOnline;
     }
     registerPreviewPanel(previewPanel) {
-        previewPanel.signals = signals;
+        Reflect.set(previewPanel, PREVIEW_PANEL_SIGNALS_SYMBOL, signals);
+        Reflect.set(previewPanel, PREVIEW_PANEL_SIGNAL_FNS_SYMBOL, signalFns);
     }
 }
 const src_CoreStateful = CoreStateful;
 class CoreStateless extends src_CoreBase {
-    analytics;
-    personalization;
+    _analytics;
+    _personalization;
     constructor(config){
         super(config);
-        this.analytics = new analytics_AnalyticsStateless({
+        this._analytics = new analytics_AnalyticsStateless({
             api: this.api,
             builder: this.eventBuilder,
             interceptors: this.interceptors
         });
-        this.personalization = new personalization_PersonalizationStateless({
+        this._personalization = new personalization_PersonalizationStateless({
             api: this.api,
             builder: this.eventBuilder,
             interceptors: this.interceptors
@@ -1529,7 +1826,8 @@ class CoreStateless extends src_CoreBase {
     }
 }
 const src_CoreStateless = CoreStateless;
-export * from "@contentful/optimization-api-client";
-export { ANONYMOUS_ID_COOKIE, ConsoleLogSink, InterceptorManager, Logger, OPTIMIZATION_CORE_SDK_VERSION, analytics_AnalyticsStateful as AnalyticsStateful, analytics_AnalyticsStateless as AnalyticsStateless, batch, createScopedLogger, effect, guardedBy, logger, personalization_PersonalizationStateful as PersonalizationStateful, personalization_PersonalizationStateless as PersonalizationStateless, resolvers_FlagsResolver as FlagsResolver, resolvers_MergeTagValueResolver as MergeTagValueResolver, resolvers_PersonalizedEntryResolver as PersonalizedEntryResolver, signals, src_CoreStateful as CoreStateful, src_CoreStateless as CoreStateless, src_LogSink as LogSink, value_presence_ValuePresence as ValuePresence };
+export { ANONYMOUS_ID_COOKIE, ANONYMOUS_ID_COOKIE_LEGACY, ANONYMOUS_ID_KEY, ANONYMOUS_ID_KEY_LEGACY, CHANGES_CACHE_KEY, CONSENT_KEY, DEBUG_FLAG_KEY, OPTIMIZATION_CORE_SDK_NAME, OPTIMIZATION_CORE_SDK_VERSION, PERSONALIZATIONS_CACHE_KEY, PROFILE_CACHE_KEY } from "./260.mjs";
+export { PREVIEW_PANEL_SIGNALS_SYMBOL, PREVIEW_PANEL_SIGNAL_FNS_SYMBOL } from "./632.mjs";
+export { InterceptorManager, analytics_AnalyticsStateful as AnalyticsStateful, analytics_AnalyticsStateless as AnalyticsStateless, batch, effect, guardedBy, personalization_PersonalizationBase as PersonalizationBase, personalization_PersonalizationStateful as PersonalizationStateful, personalization_PersonalizationStateless as PersonalizationStateless, resolvers_FlagsResolver as FlagsResolver, resolvers_MergeTagValueResolver as MergeTagValueResolver, resolvers_PersonalizedEntryResolver as PersonalizedEntryResolver, signalFns, signals, src_CoreStateful as CoreStateful, src_CoreStateless as CoreStateless };
 
 //# sourceMappingURL=index.mjs.map