diff --git a/.prettierignore b/.prettierignore
index f3c08f37..52103794 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -6,3 +6,4 @@ pnpm-lock.yaml
 **/android/.gradle/**
 **/.bundle/**
 **/node_modules/**
+packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Resources/optimization-ios-bridge.umd.js
\ No newline at end of file
diff --git a/implementations/PREVIEW_PANEL_SCENARIOS.md b/implementations/PREVIEW_PANEL_SCENARIOS.md
new file mode 100644
index 00000000..7194bafd
--- /dev/null
+++ b/implementations/PREVIEW_PANEL_SCENARIOS.md
@@ -0,0 +1,187 @@
+# Preview Panel E2E Scenarios (Cross-Platform Contract)
+
+This document is the **shared contract** driving preview-panel E2E tests on both React Native
+(Detox) and iOS (XCUITest). Both suites MUST mirror scenario names, data, and expected observations
+so cross-platform drift is immediately visible when diffing test output.
+
+## Why these tests exist
+
+The shared `PreviewOverrideManager`
+(`packages/universal/core-sdk/src/lib/preview/PreviewOverrideManager.ts`) has strong unit coverage.
+These E2E tests exist to verify the **thin platform wrappers** correctly:
+
+1. Invoke manager methods from UI controls
+2. Propagate signal changes through to rendered content
+3. Preserve overrides across API refresh (interceptor path)
+
+The E2E suite deliberately does **not** re-test manager logic (variant arithmetic, multi-index
+scenarios, etc.) — that is already unit-covered.
+
+## Harness requirements
+
+**Preconditions for both platforms:**
+
+- Mock server running at `localhost:8000` (`pnpm --filter @contentful/optimization-mocks serve`)
+- Reference app identifies as an "identified visitor" so `identified-visitor.json` is served
+- App launched fresh (no cached overrides)
+
+**Assertion style:** rendered-content only. Each scenario drives preview-panel UI then observes
+`entry-text-{entryId}` visibility. No debug-state labels are injected into the panel.
+
+## Fixture data
+
+All scenarios use:
+
+- **Test audience**: `4yIqY7AWtzeehCZxtQSDB` ("Identified Users") — user qualifies naturally
+- **Test experience**: `7DyidZaPB7Jr1gWKjoogg0` ("Personalization Nested Level 1"), audience-linked
+  to the test audience
+  - Baseline entry: `5i4SdJXw9oDEY0vgO7CwF4` — text "This is a level 1 nested baseline entry."
+  - Variant entry: `5a8ONfBdanJtlJ39WWnH1w` — text "This is a level 1 nested variant entry."
+- **Secondary experience**: `6IueRX1pS3iMJncbhUQTba` ("Personalization Nested Level 2"), also
+  audience-linked
+  - Baseline entry: `uaNY4YJ0HFPAX3gKXiRdX` — "baseline level 2"
+  - Variant entry: `4hDiXxYEFrXHXcQgmdL9Uv` — "variant level 2"
+
+Default state for an identified user: both experiences render their **variant** entries
+(`5a8ONfBdanJtlJ39WWnH1w`, `4hDiXxYEFrXHXcQgmdL9Uv`). This is already asserted by
+`displays-identified-user-variants.test.js` and `IdentifiedVariantsTests.swift` and serves as the
+pre-test baseline.
+
+## Shared accessibility identifiers / testIDs
+
+| Control                            | ID                                                    |
+| ---------------------------------- | ----------------------------------------------------- |
+| Open preview panel (FAB)           | `preview-panel-fab`                                   |
+| Close preview panel                | `preview-panel-close`                                 |
+| Audience toggle (On/Default/Off)   | `audience-toggle-{audienceId}-{on\|default\|off}`     |
+| Audience toggle container          | `audience-toggle-{audienceId}` (RN only — radiogroup) |
+| Variant picker (per option)        | `variant-picker-{experienceId}-{index}`               |
+| Reset individual audience override | `reset-audience-{audienceId}`                         |
+| Reset individual variant override  | `reset-variant-{experienceId}`                        |
+| Reset all overrides (footer)       | `reset-all-overrides`                                 |
+
+Identifiers are identical on iOS (accessibilityIdentifier) and RN (testID). Keep them in sync when
+adding new controls.
+
+## Scenarios
+
+Each scenario: open panel → drive UI → close panel → assert rendered content. `TEST_EXPERIENCE_ID`
+below = `7DyidZaPB7Jr1gWKjoogg0`, `TEST_AUDIENCE_ID` = `4yIqY7AWtzeehCZxtQSDB`.
+
+### 1. Activate an unqualified audience renders variants
+
+Starting state: user is _not_ qualified for some audience X (pick one absent from
+`profile.audiences` in the mock). Rendered entries linked to X show baseline.
+
+Drive:
+
+1. Tap `preview-panel-fab`
+2. Tap `audience-toggle-{X}-on`
+3. Tap `preview-panel-close`
+
+Assert: entries linked to X now render their variant text.
+
+> **Note**: requires an audience the identified user does NOT qualify for. If the mock's identified
+> profile qualifies for every audience with content, extend the mock to add one unqualified
+> audience + experience. Skip scenario if not yet possible; log as known gap.
+
+### 2. Deactivate a qualified audience renders baselines
+
+Starting state: user qualifies for `TEST_AUDIENCE_ID`, `TEST_EXPERIENCE_ID` renders variant
+`5a8ONfBdanJtlJ39WWnH1w`.
+
+Drive:
+
+1. Tap `preview-panel-fab`
+2. Tap `audience-toggle-4yIqY7AWtzeehCZxtQSDB-off`
+3. Tap `preview-panel-close`
+
+Assert: `entry-text-5i4SdJXw9oDEY0vgO7CwF4` (baseline) visible; variant no longer visible.
+
+### 3. Reset audience override restores qualified state
+
+Continuing from scenario 2 (audience is deactivated, baseline visible).
+
+Drive:
+
+1. Tap `preview-panel-fab`
+2. Tap `audience-toggle-4yIqY7AWtzeehCZxtQSDB-default`
+3. Tap `preview-panel-close`
+
+Assert: `entry-text-5a8ONfBdanJtlJ39WWnH1w` (variant) visible again.
+
+### 4. Set variant override to baseline renders baseline
+
+Starting state: experience renders variant.
+
+Drive:
+
+1. Tap `preview-panel-fab`
+2. Expand `TEST_AUDIENCE_ID` audience if needed
+3. Tap `variant-picker-7DyidZaPB7Jr1gWKjoogg0-0`
+4. Tap `preview-panel-close`
+
+Assert: `entry-text-5i4SdJXw9oDEY0vgO7CwF4` (baseline) visible.
+
+### 5. Reset single variant override restores default
+
+Continuing from scenario 4 (variant override to index 0 set).
+
+Drive:
+
+1. Tap `preview-panel-fab`
+2. Scroll to Overrides section
+3. Tap `reset-variant-7DyidZaPB7Jr1gWKjoogg0`
+4. Confirm the alert (iOS: "Reset" button; RN: Alert "Reset" button)
+5. Tap `preview-panel-close`
+
+Assert: variant content visible again.
+
+### 6. Reset all overrides restores every experience
+
+Setup: drive scenarios 2 + 4 so both an audience override and a variant override exist.
+
+Drive:
+
+1. Tap `preview-panel-fab`
+2. Scroll to footer
+3. Tap `reset-all-overrides`
+4. Confirm alert ("Reset")
+5. Tap `preview-panel-close`
+
+Assert: all test experiences render their default (variant) content.
+
+### 7. Override survives API refresh
+
+Setup: drive scenario 2 (audience deactivated, baseline rendering).
+
+Drive:
+
+1. Tap `preview-panel-fab`
+2. Tap `preview-refresh-button` (existing)
+3. Tap `preview-panel-close`
+
+Assert: baseline still rendering — the interceptor preserved the override through the API refresh.
+
+### 8. Destroy/remount — overrides do not leak
+
+Drive: set an override (scenario 2), close the app via platform API (`device.terminateApp()` /
+`app.terminate()`), relaunch.
+
+Assert: test experience renders default (variant) content; preview panel Overrides section empty.
+
+## Running locally
+
+- **RN (Android)**:
+  `pnpm --filter @contentful/optimization-react-native-reference-app test:e2e:android` (or iOS sim
+  equivalent)
+- **iOS native**:
+  `xcodebuild test -scheme OptimizationApp -only-testing:OptimizationAppUITests/PreviewPanelOverridesTests -destination 'platform=iOS Simulator,name=iPhone 16'`
+
+## Gaps / Known Limitations
+
+- **Scenario 1** (activate unqualified audience) currently unverifiable unless the mock is extended
+  with an audience the identified user does not qualify for. Document as TODO on the test, or adjust
+  the mock profile.
+- **Multi-index variant pickers**: all mock experiences are binary (index 0 or 1). Higher-index
+  arithmetic is unit-tested at manager level.
diff --git a/implementations/ios-sdk/OptimizationApp/App.swift b/implementations/ios-sdk/OptimizationApp/App.swift
index 20f8a660..f41956b1 100644
--- a/implementations/ios-sdk/OptimizationApp/App.swift
+++ b/implementations/ios-sdk/OptimizationApp/App.swift
@@ -3,6 +3,16 @@ import SwiftUI
 
 @main
 struct OptimizationDemoApp: App {
+    init() {
+        // UI tests launch with `--reset` to guarantee an unidentified-visitor
+        // starting state. The SDK persists `anonymousId`/profile in its own
+        // UserDefaults suite, and those outlive `terminate()` + `launch()` on
+        // the simulator — so an explicit wipe is the only reliable reset.
+        if ProcessInfo.processInfo.arguments.contains("--reset") {
+            UserDefaults.standard.removePersistentDomain(forName: "com.contentful.optimization")
+        }
+    }
+
     var body: some Scene {
         WindowGroup {
             OptimizationRoot(
diff --git a/implementations/ios-sdk/OptimizationAppUITests/Tests/PreviewPanelOverridesTests.swift b/implementations/ios-sdk/OptimizationAppUITests/Tests/PreviewPanelOverridesTests.swift
new file mode 100644
index 00000000..b10d9e01
--- /dev/null
+++ b/implementations/ios-sdk/OptimizationAppUITests/Tests/PreviewPanelOverridesTests.swift
@@ -0,0 +1,124 @@
+import XCTest
+
+/// Cross-platform preview-panel override scenarios (iOS side).
+///
+/// Scenarios mirror `implementations/PREVIEW_PANEL_SCENARIOS.md` and the RN
+/// Detox suite `preview-panel-overrides.test.js`. Keep test names and fixture
+/// IDs identical across platforms so cross-platform regressions are visible.
+final class PreviewPanelOverridesTests: XCTestCase {
+    let app = XCUIApplication()
+
+    static let AUDIENCE_ID = "4yIqY7AWtzeehCZxtQSDB"
+    static let EXPERIENCE_ID = "7DyidZaPB7Jr1gWKjoogg0"
+    static let VARIANT_ENTRY_ID = "5a8ONfBdanJtlJ39WWnH1w"
+    static let BASELINE_ENTRY_ID = "5i4SdJXw9oDEY0vgO7CwF4"
+
+    override func setUp() {
+        continueAfterFailure = false
+        app.launch()
+        clearProfileState(app: app)
+        identifyAndWaitForEntries()
+    }
+
+    // MARK: - Helpers
+
+    private func identifyAndWaitForEntries() {
+        let identifyButton = app.buttons["identify-button"]
+        waitForElement(identifyButton)
+        identifyButton.tap()
+        waitForElement(app.buttons["reset-button"])
+
+        // Identified-visitor profile should render variant entries by default.
+        let variantEntry = findElement("entry-text-\(Self.VARIANT_ENTRY_ID)", app: app)
+        XCTAssertTrue(variantEntry.waitForExistence(timeout: ELEMENT_VISIBILITY_TIMEOUT),
+                      "Expected variant entry to render after identify")
+    }
+
+    private func openPanel() {
+        let fab = app.buttons["preview-panel-fab"]
+        waitForElement(fab)
+        fab.tap()
+        XCTAssertTrue(app.staticTexts["Preview Panel"].waitForExistence(timeout: ELEMENT_VISIBILITY_TIMEOUT),
+                      "Preview Panel did not appear")
+    }
+
+    private func closePanel() {
+        // The panel sheet is dismissed via the drag handle or close button;
+        // sheets can also be dismissed by swiping down on the header.
+        let dismissGesture = app.navigationBars.buttons.firstMatch
+        if dismissGesture.exists {
+            dismissGesture.tap()
+            return
+        }
+        // Fallback: swipe down from top of sheet to dismiss.
+        app.swipeDown()
+    }
+
+    private func assertEntryVisible(_ entryId: String, message: String) {
+        let entry = findElement("entry-text-\(entryId)", app: app)
+        XCTAssertTrue(entry.waitForExistence(timeout: ELEMENT_VISIBILITY_TIMEOUT), message)
+    }
+
+    // MARK: - Scenarios
+
+    func testScenario2DeactivatingQualifiedAudienceRendersBaseline() {
+        openPanel()
+        let toggle = app.buttons["audience-toggle-\(Self.AUDIENCE_ID)-off"]
+        XCTAssertTrue(toggle.waitForExistence(timeout: ELEMENT_VISIBILITY_TIMEOUT),
+                      "Off toggle not found for audience")
+        toggle.tap()
+        closePanel()
+
+        assertEntryVisible(Self.BASELINE_ENTRY_ID,
+                           message: "Expected baseline entry after deactivating audience")
+    }
+
+    func testScenario3ResettingAudienceOverrideRestoresVariant() {
+        // Set up by first deactivating, then resetting to default.
+        openPanel()
+        app.buttons["audience-toggle-\(Self.AUDIENCE_ID)-off"].tap()
+        app.buttons["audience-toggle-\(Self.AUDIENCE_ID)-default"].tap()
+        closePanel()
+
+        assertEntryVisible(Self.VARIANT_ENTRY_ID,
+                           message: "Expected variant entry after resetting audience override")
+    }
+
+    func testScenario4SettingVariantOverrideToZeroRendersBaseline() {
+        openPanel()
+        let picker = app.buttons["variant-picker-\(Self.EXPERIENCE_ID)-0"]
+        XCTAssertTrue(picker.waitForExistence(timeout: ELEMENT_VISIBILITY_TIMEOUT),
+                      "Variant picker baseline option not found")
+        picker.tap()
+        closePanel()
+
+        assertEntryVisible(Self.BASELINE_ENTRY_ID,
+                           message: "Expected baseline after variant-0 override")
+    }
+
+    func testScenario6ResetAllRestoresVariantContent() {
+        // Apply a variant override, then reset all.
+        openPanel()
+        app.buttons["variant-picker-\(Self.EXPERIENCE_ID)-0"].tap()
+        let resetAll = app.buttons["reset-all-overrides"]
+        XCTAssertTrue(resetAll.waitForExistence(timeout: ELEMENT_VISIBILITY_TIMEOUT),
+                      "Reset-all button not found")
+        resetAll.tap()
+
+        // Confirm the alert.
+        let resetButton = app.alerts.buttons["Reset"]
+        XCTAssertTrue(resetButton.waitForExistence(timeout: ELEMENT_VISIBILITY_TIMEOUT),
+                      "Reset confirmation button not found")
+        resetButton.tap()
+        closePanel()
+
+        assertEntryVisible(Self.VARIANT_ENTRY_ID,
+                           message: "Expected variant entry after reset-all")
+    }
+
+    // TODO: scenarios 1, 5, 7, 8 — see implementations/PREVIEW_PANEL_SCENARIOS.md.
+    // - 1 (activate unqualified audience) requires a mock audience the identified user does not qualify for.
+    // - 5 (reset single variant override) taps the per-item reset button in the Overrides section.
+    // - 7 (override survives API refresh) drives preview-refresh-button between open/close.
+    // - 8 (destroy/remount) uses app.terminate() + app.launch().
+}
diff --git a/implementations/ios-sdk/OptimizationAppUITests/Tests/PreviewPanelTests.swift b/implementations/ios-sdk/OptimizationAppUITests/Tests/PreviewPanelTests.swift
index 3f2ed4dc..f11b7973 100644
--- a/implementations/ios-sdk/OptimizationAppUITests/Tests/PreviewPanelTests.swift
+++ b/implementations/ios-sdk/OptimizationAppUITests/Tests/PreviewPanelTests.swift
@@ -23,10 +23,21 @@ final class PreviewPanelTests: XCTestCase {
     }
 
     /// Scrolls the preview panel list until the target element is visible.
+    /// SwiftUI List renders as collectionView; plain ScrollView as scrollView.
+    /// Prefer an identifier match; fall back to the first match of either type.
     private func scrollToPreviewElement(_ testId: String, maxSwipes: Int = 10) {
-        // SwiftUI List renders as collectionView on modern iOS
-        let list = app.collectionViews["preview-panel-list"]
-        let scrollContainer = list.exists ? list : app.collectionViews.firstMatch
+        let listById = app.collectionViews["preview-panel-list"]
+        let scrollById = app.scrollViews["preview-panel-list"]
+        let scrollContainer: XCUIElement
+        if listById.exists {
+            scrollContainer = listById
+        } else if scrollById.exists {
+            scrollContainer = scrollById
+        } else if app.collectionViews.firstMatch.exists {
+            scrollContainer = app.collectionViews.firstMatch
+        } else {
+            scrollContainer = app.scrollViews.firstMatch
+        }
         for _ in 0..<maxSwipes {
             let target = findElement(testId, app: app)
             if target.exists && target.isHittable { return }
diff --git a/implementations/ios-sdk/OptimizationAppUITests/Tests/UnidentifiedVariantsTests.swift b/implementations/ios-sdk/OptimizationAppUITests/Tests/UnidentifiedVariantsTests.swift
index 7b12a04b..edae4a3d 100644
--- a/implementations/ios-sdk/OptimizationAppUITests/Tests/UnidentifiedVariantsTests.swift
+++ b/implementations/ios-sdk/OptimizationAppUITests/Tests/UnidentifiedVariantsTests.swift
@@ -5,8 +5,15 @@ final class UnidentifiedVariantsTests: XCTestCase {
 
     override func setUp() {
         continueAfterFailure = false
-        app.launch()
-        clearProfileState(app: app)
+        // These tests assert the new-visitor mock fixture is served, which the
+        // mock server routes by the persisted `anonymousId`. An in-app reset
+        // via the button only clears state when the user is currently
+        // identified — if the simulator already booted into an unidentified
+        // surface, `clearProfileState` returns immediately and any stale
+        // `anonymousId` stays around, so the mock keeps serving the
+        // identified-visitor fixture. `requireFreshAppInstance: true` triggers
+        // `--reset`, which wipes the SDK's UserDefaults suite on launch.
+        clearProfileState(app: app, requireFreshAppInstance: true)
     }
 
     func testDisplaysMergeTagEntry() {
diff --git a/implementations/ios-sdk/README.md b/implementations/ios-sdk/README.md
new file mode 100644
index 00000000..d6ea6dc3
--- /dev/null
+++ b/implementations/ios-sdk/README.md
@@ -0,0 +1,45 @@
+# Optimization iOS Reference App
+
+Reference app for the iOS Optimization SDK. Exercises the SDK against the mock server in
+`lib/mocks/` and hosts the XCUITest suite.
+
+## UI Tests
+
+All UI tests live under `OptimizationAppUITests/Tests/`. They assume the mock server is running at
+`http://localhost:8000`:
+
+```sh
+pnpm --filter @contentful/optimization-mocks serve
+```
+
+Run the full suite locally:
+
+```sh
+xcodebuild test \
+  -project OptimizationApp.xcodeproj \
+  -scheme OptimizationApp \
+  -destination 'platform=iOS Simulator,name=iPhone 16'
+```
+
+Run only the preview-panel override suite (recommended during development of that feature):
+
+```sh
+xcodebuild test \
+  -project OptimizationApp.xcodeproj \
+  -scheme OptimizationApp \
+  -destination 'platform=iOS Simulator,name=iPhone 16' \
+  -only-testing:OptimizationAppUITests/PreviewPanelOverridesTests
+```
+
+### Adding new test files
+
+XCUITest source files must be added to the `OptimizationAppUITests` target in Xcode before they're
+compiled. Adding a `.swift` file to `OptimizationAppUITests/Tests/` on disk is **not** enough — open
+the project in Xcode and confirm the new file's Target Membership includes `OptimizationAppUITests`.
+
+## Preview panel tests
+
+The preview-panel override suite mirrors the React Native Detox suite in
+`implementations/react-native-sdk/e2e/preview-panel-overrides.test.js`. Both reference the shared
+contract document at `implementations/PREVIEW_PANEL_SCENARIOS.md`. Keep scenario names and fixture
+IDs identical across platforms so cross-platform regressions are visible in CI diffs.
diff --git a/implementations/react-native-sdk/App.tsx b/implementations/react-native-sdk/App.tsx
index 5b4d3046..c016af28 100644
--- a/implementations/react-native-sdk/App.tsx
+++ b/implementations/react-native-sdk/App.tsx
@@ -1,13 +1,14 @@
-import React, { useEffect, useState } from 'react'
+import React, { useEffect, useMemo, useState } from 'react'
 import { Button, Text, View } from 'react-native'
 import { SafeAreaView } from 'react-native-safe-area-context'
 
 import {
   OptimizationProvider,
   OptimizationScrollProvider,
+  PreviewPanelOverlay,
   useOptimization,
 } from '@contentful/optimization-react-native'
-import type { Entry } from 'contentful'
+import { createClient, type Entry } from 'contentful'
 
 import { AnalyticsEventDisplay } from './components/AnalyticsEventDisplay'
 import { ENV_CONFIG } from './env.config'
@@ -30,6 +31,18 @@ const ENTRY_IDS = [
 
 function AppContent(): React.JSX.Element {
   const sdk = useOptimization()
+  const contentfulClient = useMemo(
+    () =>
+      createClient({
+        space: ENV_CONFIG.contentful.spaceId,
+        environment: ENV_CONFIG.contentful.environment,
+        accessToken: ENV_CONFIG.contentful.accessToken,
+        host: ENV_CONFIG.contentful.host,
+        basePath: ENV_CONFIG.contentful.basePath,
+        insecure: true,
+      }),
+    [],
+  )
   const [entries, setEntries] = useState<Entry[]>([])
   const [sdkError, setSdkError] = useState<string | null>(null)
   const [hasConsent, setHasConsent] = useState<boolean>(false)
@@ -116,39 +129,41 @@ function AppContent(): React.JSX.Element {
   }
 
   return (
-    <SafeAreaView style={{ flex: 1 }}>
-      <View style={{ padding: 10, gap: 10, flexDirection: 'row', flexWrap: 'wrap' }}>
-        {!isIdentified ? (
-          <Button testID="identify-button" title="Identify" onPress={handleIdentify} />
-        ) : (
-          <Button testID="reset-button" title="Reset" onPress={handleReset} />
-        )}
-        <Button
-          testID="navigation-test-button"
-          title="Navigation Test"
-          onPress={() => {
-            setShowNavigationTest(true)
-          }}
-        />
-        <Button
-          testID="live-updates-test-button"
-          title="Live Updates Test"
-          onPress={() => {
-            setShowLiveUpdatesTest(true)
-          }}
-        />
-      </View>
-      <OptimizationScrollProvider testID="main-scroll-view">
-        {entries.map((entry) =>
-          entry.sys.contentType.sys.id === 'nestedContent' ? (
-            <NestedContentEntry key={entry.sys.id} entry={entry} />
+    <PreviewPanelOverlay contentfulClient={contentfulClient}>
+      <SafeAreaView style={{ flex: 1 }}>
+        <View style={{ padding: 10, gap: 10, flexDirection: 'row', flexWrap: 'wrap' }}>
+          {!isIdentified ? (
+            <Button testID="identify-button" title="Identify" onPress={handleIdentify} />
           ) : (
-            <ContentEntry key={entry.sys.id} entry={entry} />
-          ),
-        )}
-        <AnalyticsEventDisplay />
-      </OptimizationScrollProvider>
-    </SafeAreaView>
+            <Button testID="reset-button" title="Reset" onPress={handleReset} />
+          )}
+          <Button
+            testID="navigation-test-button"
+            title="Navigation Test"
+            onPress={() => {
+              setShowNavigationTest(true)
+            }}
+          />
+          <Button
+            testID="live-updates-test-button"
+            title="Live Updates Test"
+            onPress={() => {
+              setShowLiveUpdatesTest(true)
+            }}
+          />
+        </View>
+        <OptimizationScrollProvider testID="main-scroll-view">
+          {entries.map((entry) =>
+            entry.sys.contentType.sys.id === 'nestedContent' ? (
+              <NestedContentEntry key={entry.sys.id} entry={entry} />
+            ) : (
+              <ContentEntry key={entry.sys.id} entry={entry} />
+            ),
+          )}
+          <AnalyticsEventDisplay />
+        </OptimizationScrollProvider>
+      </SafeAreaView>
+    </PreviewPanelOverlay>
   )
 }
 
diff --git a/implementations/react-native-sdk/e2e/preview-panel-overrides.test.js b/implementations/react-native-sdk/e2e/preview-panel-overrides.test.js
new file mode 100644
index 00000000..7a1a2785
--- /dev/null
+++ b/implementations/react-native-sdk/e2e/preview-panel-overrides.test.js
@@ -0,0 +1,143 @@
+/**
+ * Cross-platform preview-panel override scenarios.
+ *
+ * Scenarios mirror `implementations/PREVIEW_PANEL_SCENARIOS.md` and the iOS
+ * `PreviewPanelOverridesTests` XCUITest suite. Keep scenario names and
+ * data identical so cross-platform regressions are visible in CI diff.
+ */
+
+const { clearProfileState, ELEMENT_VISIBILITY_TIMEOUT, isVisibleById } = require('./helpers')
+
+const AUDIENCE_ID = '4yIqY7AWtzeehCZxtQSDB'
+const EXPERIENCE_ID = '7DyidZaPB7Jr1gWKjoogg0'
+const VARIANT_ENTRY_ID = '5a8ONfBdanJtlJ39WWnH1w'
+const BASELINE_ENTRY_ID = '5i4SdJXw9oDEY0vgO7CwF4'
+
+async function identifyAndRelaunch() {
+  await waitFor(element(by.id('identify-button')))
+    .toBeVisible()
+    .withTimeout(ELEMENT_VISIBILITY_TIMEOUT)
+  await element(by.id('identify-button')).tap()
+  await waitFor(element(by.id('reset-button')))
+    .toBeVisible()
+    .withTimeout(ELEMENT_VISIBILITY_TIMEOUT)
+  // Existing identified-variant tests terminate+relaunch here so the app
+  // re-fetches the identified-visitor mock payload on fresh launch.
+  await device.terminateApp()
+  await device.launchApp({ newInstance: true })
+  // Identified-visitor profile should render variant entries by default.
+  await waitFor(element(by.id(`entry-text-${VARIANT_ENTRY_ID}`)))
+    .toExist()
+    .withTimeout(ELEMENT_VISIBILITY_TIMEOUT)
+}
+
+async function openPanel() {
+  await waitFor(element(by.id('preview-panel-fab')))
+    .toExist()
+    .withTimeout(ELEMENT_VISIBILITY_TIMEOUT)
+  await element(by.id('preview-panel-fab')).tap()
+  await waitFor(element(by.text('Preview Panel')))
+    .toBeVisible()
+    .withTimeout(ELEMENT_VISIBILITY_TIMEOUT)
+}
+
+/**
+ * Scrolls the preview panel's internal ScrollView until the target element
+ * is visible enough to be tappable. The panel is tall and target audiences
+ * are typically below the fold.
+ */
+async function scrollPanelToId(testId) {
+  await waitFor(element(by.id(testId)))
+    .toBeVisible()
+    .whileElement(by.type('android.widget.ScrollView'))
+    .scroll(300, 'down')
+}
+
+async function closePanel() {
+  // Press system back to dismiss the modal; this fires onRequestClose on Android
+  // and the standard swipe-to-dismiss on iOS.
+  try {
+    await device.pressBack()
+  } catch {
+    // iOS has no hardware back; fall back to our close button testID.
+    if (await isVisibleById('preview-panel-close', 1000)) {
+      await element(by.id('preview-panel-close')).tap()
+    }
+  }
+}
+
+describe('preview panel overrides', () => {
+  // Launch fresh before every scenario so modal state and override state
+  // from a prior scenario can't leak into the next one.
+  beforeEach(async () => {
+    await device.launchApp({ newInstance: true, delete: true })
+    await clearProfileState()
+    await identifyAndRelaunch()
+  })
+
+  it('scenario 2: deactivating qualified audience renders baseline', async () => {
+    await openPanel()
+    await scrollPanelToId(`audience-toggle-${AUDIENCE_ID}-off`)
+    await element(by.id(`audience-toggle-${AUDIENCE_ID}-off`)).tap()
+    await closePanel()
+    // Wait briefly for the signal update to propagate into re-rendered entries.
+    await waitFor(element(by.id(`entry-text-${BASELINE_ENTRY_ID}`)))
+      .toExist()
+      .withTimeout(ELEMENT_VISIBILITY_TIMEOUT)
+  })
+
+  it('scenario 3: resetting audience override restores variant', async () => {
+    // First deactivate so there is an override to reset.
+    await openPanel()
+    await scrollPanelToId(`audience-toggle-${AUDIENCE_ID}-off`)
+    await element(by.id(`audience-toggle-${AUDIENCE_ID}-off`)).tap()
+    await element(by.id(`audience-toggle-${AUDIENCE_ID}-default`)).tap()
+    await closePanel()
+
+    await waitFor(element(by.id(`entry-text-${VARIANT_ENTRY_ID}`)))
+      .toExist()
+      .withTimeout(ELEMENT_VISIBILITY_TIMEOUT)
+  })
+
+  it('scenario 4: setting variant override to 0 renders baseline', async () => {
+    await openPanel()
+    // The audience must be expanded for its experience variant picker to mount.
+    await scrollPanelToId(`audience-toggle-${AUDIENCE_ID}-off`)
+    // Tap audience header row to expand experiences.
+    await element(by.text('Identified Users')).tap()
+    await scrollPanelToId(`variant-picker-${EXPERIENCE_ID}-0`)
+    await element(by.id(`variant-picker-${EXPERIENCE_ID}-0`)).tap()
+    await closePanel()
+
+    await waitFor(element(by.id(`entry-text-${BASELINE_ENTRY_ID}`)))
+      .toExist()
+      .withTimeout(ELEMENT_VISIBILITY_TIMEOUT)
+  })
+
+  it('scenario 6: reset-all restores variant content', async () => {
+    // Set a variant override, then reset all.
+    await openPanel()
+    await scrollPanelToId(`audience-toggle-${AUDIENCE_ID}-off`)
+    await element(by.text('Identified Users')).tap()
+    await scrollPanelToId(`variant-picker-${EXPERIENCE_ID}-0`)
+    await element(by.id(`variant-picker-${EXPERIENCE_ID}-0`)).tap()
+    await scrollPanelToId('reset-all-overrides')
+    await element(by.id('reset-all-overrides')).tap()
+    // Confirm alert.
+    await waitFor(element(by.text('Reset')))
+      .toBeVisible()
+      .withTimeout(ELEMENT_VISIBILITY_TIMEOUT)
+    await element(by.text('Reset')).atIndex(0).tap()
+    await closePanel()
+
+    await waitFor(element(by.id(`entry-text-${VARIANT_ENTRY_ID}`)))
+      .toExist()
+      .withTimeout(ELEMENT_VISIBILITY_TIMEOUT)
+  })
+
+  // TODO: scenarios 1, 5, 7, 8 — see implementations/PREVIEW_PANEL_SCENARIOS.md.
+  // - 1 (activate unqualified audience) requires a mock audience the identified user does not qualify for.
+  // - 5 (reset single variant override) requires tapping the per-item reset button inside the Overrides section.
+  // - 7 (override survives API refresh) drives the existing preview-refresh-button.
+  // - 8 (destroy/remount) uses device.terminateApp() + device.launchApp({ delete: true }).
+})
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Bridge/JSContextManager.swift b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Bridge/JSContextManager.swift
index 43759980..35076097 100644
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Bridge/JSContextManager.swift
+++ b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Bridge/JSContextManager.swift
@@ -18,6 +18,7 @@ final class JSContextManager {
     var onLog: ((String, String) -> Void)?
     var onStateChange: (([String: Any]) -> Void)?
     var onEvent: (([String: Any]) -> Void)?
+    var onOverridesChanged: ((PreviewState) -> Void)?
 
     /// Creates the JSContext, loads polyfills and the UMD bundle, and calls `__bridge.initialize()`.
     func initialize(config: OptimizationConfig) throws {
@@ -76,6 +77,15 @@ final class JSContextManager {
         }
         ctx.setObject(onEventEmitted, forKeyedSubscript: "__nativeOnEventEmitted" as NSString)
 
+        // Register overrides-changed callback. The JS bridge calls
+        // __nativeOnOverridesChanged(JSON.stringify(previewState)) after every
+        // PreviewOverrideManager mutation — the "push model" that keeps iOS UI
+        // in sync without polling getPreviewState() after each action.
+        let onOverridesChangedBlock: @convention(block) (String) -> Void = { [weak self] json in
+            self?.handleOverridesChanged(json)
+        }
+        ctx.setObject(onOverridesChangedBlock, forKeyedSubscript: "__nativeOnOverridesChanged" as NSString)
+
         // Initialize the bridge
         let configJSON: String
         do {
@@ -225,4 +235,14 @@ final class JSContextManager {
             self?.onEvent?(dict)
         }
     }
+
+    private func handleOverridesChanged(_ json: String) {
+        guard let data = json.data(using: .utf8),
+              let state = try? JSONDecoder().decode(PreviewState.self, from: data)
+        else { return }
+
+        DispatchQueue.main.async { [weak self] in
+            self?.onOverridesChanged?(state)
+        }
+    }
 }
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationClient.swift b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationClient.swift
index 15b88625..bb04b419 100644
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationClient.swift
+++ b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationClient.swift
@@ -34,6 +34,12 @@ public final class OptimizationClient: ObservableObject {
     /// so that override changes are reflected immediately.
     @Published public private(set) var isPreviewPanelOpen = false
 
+    /// The latest preview state pushed from the JS bridge whenever
+    /// `PreviewOverrideManager` mutates overrides. Mirrors the React Native
+    /// `useProfileOverrides` push model: consumers observe this publisher
+    /// rather than polling ``getPreviewState()`` after each action.
+    @Published public private(set) var previewState: PreviewState?
+
     private let bridge = JSContextManager()
     private var cancellables = Set<AnyCancellable>()
     private let store = UserDefaultsStore()
@@ -59,6 +65,9 @@ public final class OptimizationClient: ObservableObject {
         bridge.onEvent = { [weak self] dict in
             self?.eventSubject.send(dict)
         }
+        bridge.onOverridesChanged = { [weak self] state in
+            self?.previewState = state
+        }
     }
 
     // MARK: - Public API
@@ -131,8 +140,7 @@ public final class OptimizationClient: ObservableObject {
 
     /// Track a screen view. Returns the server response as a dictionary.
     public func screen(name: String, properties: [String: Any]? = nil) async throws -> [String: Any]? {
-        eventSubject.send(["type": "screen", "name": name])
-        return try await bridgeCallAsyncJSON(method: "screen") {
+        try await bridgeCallAsyncJSON(method: "screen") {
             var payloadDict: [String: Any] = ["name": name]
             if let properties = properties {
                 payloadDict["properties"] = properties
@@ -240,10 +248,11 @@ public final class OptimizationClient: ObservableObject {
         bridgeCallSyncWhenInitialized(method: "setPreviewPanelOpen", args: open ? "true" : "false")
     }
 
-    /// Override an audience's qualification state.
-    public func overrideAudience(id: String, qualified: Bool) {
+    /// Override an audience's qualification state and set variant overrides for associated experiences.
+    public func overrideAudience(id: String, qualified: Bool, experienceIds: [String]) {
         let escapedId = NativePolyfills.escapeForJS(id)
-        bridgeCallSyncWhenInitialized(method: "overrideAudience", args: "'\(escapedId)', \(qualified)")
+        let escapedIds = experienceIds.map { "'\(NativePolyfills.escapeForJS($0))'" }.joined(separator: ",")
+        bridgeCallSyncWhenInitialized(method: "overrideAudience", args: "'\(escapedId)', \(qualified), [\(escapedIds)]")
     }
 
     /// Override a variant for a specific experience.
@@ -269,6 +278,36 @@ public final class OptimizationClient: ObservableObject {
         bridgeCallSyncWhenInitialized(method: "resetAllOverrides")
     }
 
+    /// Hand Contentful audience and experience entries to the JS core SDK so it
+    /// can run the shared entry mappers and serve a pre-baked preview model via
+    /// ``getPreviewState()``. Call this once on panel open after fetching entries
+    /// from Contentful via ``PreviewContentfulClient``.
+    public func loadDefinitions(
+        audiences: [[String: Any]],
+        experiences: [[String: Any]]
+    ) throws {
+        let audienceData = try JSONSerialization.data(withJSONObject: audiences, options: [])
+        let experienceData = try JSONSerialization.data(withJSONObject: experiences, options: [])
+        guard
+            let audienceJSON = String(data: audienceData, encoding: .utf8),
+            let experienceJSON = String(data: experienceData, encoding: .utf8)
+        else {
+            throw OptimizationError.configError("loadDefinitions: failed to encode entries as UTF-8 JSON")
+        }
+        bridgeCallSyncWhenInitialized(
+            method: "loadDefinitions",
+            args: "\(audienceJSON), \(experienceJSON)"
+        )
+    }
+
+    /// Pull the current preview state from the JS bridge and republish it via
+    /// ``previewState``. Use this when a view needs to guarantee the publisher
+    /// reflects the latest bridge-side snapshot — typically on preview-panel
+    /// open, before any API refresh or override mutation has fired a push.
+    public func refreshPreviewState() {
+        previewState = getPreviewState()
+    }
+
     /// Get the current preview state as a typed snapshot.
     public func getPreviewState() -> PreviewState? {
         guard let result = bridge.callSync(method: "getPreviewState"),
@@ -373,7 +412,7 @@ public final class OptimizationClient: ObservableObject {
 
     private func handleStateUpdate(_ dict: [String: Any]) {
         let profile = Self.extractJSONValue(dict["profile"])
-        let changes = Self.extractJSONValue(dict["changes"])
+        let changes = Self.extractJSONArray(dict["changes"])
         let consent = dict["consent"] as? Bool
 
         if let profile = profile {
@@ -393,7 +432,7 @@ public final class OptimizationClient: ObservableObject {
         self.selectedPersonalizations = personalizations
 
         if let changes = changes {
-            log.debug("[state] Changes: \(changes.keys.count) entries")
+            log.debug("[state] Changes: \(changes.count) entries")
         }
         if let personalizations = personalizations {
             log.debug("[state] Personalizations: \(personalizations.count) entries")
@@ -404,6 +443,7 @@ public final class OptimizationClient: ObservableObject {
         store.consent = consent
         store.changes = changes
         store.personalizations = personalizations
+        store.anonymousId = (profile?["id"] as? String) ?? store.anonymousId
     }
 
     /// Extracts a JSON-compatible dictionary from a value that may be NSNull, nil, or a dict.
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationConfig.swift b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationConfig.swift
index f4eb8f66..5cc98af7 100644
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationConfig.swift
+++ b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationConfig.swift
@@ -4,13 +4,13 @@ import Foundation
 public struct StorageDefaults {
     public var consent: Bool?
     public var profile: [String: Any]?
-    public var changes: [String: Any]?
+    public var changes: [[String: Any]]?
     public var personalizations: [[String: Any]]?
 
     public init(
         consent: Bool? = nil,
         profile: [String: Any]? = nil,
-        changes: [String: Any]? = nil,
+        changes: [[String: Any]]? = nil,
         personalizations: [[String: Any]]? = nil
     ) {
         self.consent = consent
@@ -74,7 +74,7 @@ public struct OptimizationConfig {
                 defaultsDict["changes"] = changes
             }
             if let personalizations = defaults.personalizations {
-                defaultsDict["personalizations"] = personalizations
+                defaultsDict["optimizations"] = personalizations
             }
             if !defaultsDict.isEmpty {
                 dict["defaults"] = defaultsDict
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationState.swift b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationState.swift
index 89878100..4b040a0e 100644
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationState.swift
+++ b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/OptimizationState.swift
@@ -5,7 +5,7 @@ public struct OptimizationState: Equatable {
     public var profile: [String: Any]?
     public var consent: Bool?
     public var canPersonalize: Bool
-    public var changes: [String: Any]?
+    public var changes: [[String: Any]]?
 
     public static let empty = OptimizationState(
         profile: nil,
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/PreviewState.swift b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/PreviewState.swift
index c1d7a014..d003452c 100644
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/PreviewState.swift
+++ b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Core/PreviewState.swift
@@ -20,6 +20,69 @@ public struct PreviewState: Codable, Sendable {
     public let defaultAudienceQualifications: [String: Bool]?
     /// Natural variant indices captured before any overrides were applied.
     public let defaultVariantIndices: [String: Int]?
+
+    /// Pre-baked UI model assembled by the JS core SDK. Non-nil once the host has
+    /// loaded Contentful definitions via ``OptimizationClient/loadDefinitions(audiences:experiences:)``.
+    /// Native layers render from this directly rather than recomputing audience/experience shape.
+    public let previewModel: PreviewModelDTO?
+}
+
+/// DTO for a single audience definition as shaped by core's `createAudienceDefinitions`.
+public struct AudienceDefinitionDTO: Codable, Sendable {
+    public let id: String
+    public let name: String
+    public let description: String?
+}
+
+/// DTO for a variant within an experience's distribution.
+public struct VariantDistributionDTO: Codable, Sendable {
+    public let index: Int
+    public let variantRef: String
+    public let percentage: Int?
+    public let name: String?
+}
+
+/// DTO for an experience definition, enriched by core's `buildPreviewModel`
+/// with the current selection state needed to render variant chips and
+/// override indicators without Swift-side derivation.
+public struct ExperienceDefinitionDTO: Codable, Sendable {
+    public let id: String
+    public let name: String
+    /// Raw string from JS: `"nt_personalization"` or `"nt_experiment"`.
+    public let type: String
+    public let distribution: [VariantDistributionDTO]
+    public let audience: AudienceRef?
+
+    /// Current variant selected by the SDK (with any active overrides applied).
+    public let currentVariantIndex: Int
+    /// True when an active variant override exists for this experience.
+    public let isOverridden: Bool
+    /// Pre-override natural variant index; present only when `isOverridden` is true.
+    public let naturalVariantIndex: Int?
+
+    public struct AudienceRef: Codable, Sendable {
+        public let id: String
+    }
+}
+
+/// DTO for an audience combined with its experiences and computed override state.
+public struct AudienceWithExperiencesDTO: Codable, Sendable {
+    public let audience: AudienceDefinitionDTO
+    public let experiences: [ExperienceDefinitionDTO]
+    public let isQualified: Bool
+    public let isActive: Bool
+    /// Raw string from JS: `"on"`, `"off"`, or `"default"`.
+    public let overrideState: String
+}
+
+/// DTO for the pre-baked preview UI model.
+public struct PreviewModelDTO: Codable, Sendable {
+    public let audiencesWithExperiences: [AudienceWithExperiencesDTO]
+    public let unassociatedExperiences: [ExperienceDefinitionDTO]
+    public let hasData: Bool
+    public let sdkVariantIndices: [String: Int]
+    public let audienceNameMap: [String: String]
+    public let experienceNameMap: [String: String]
 }
 
 /// A selected optimization/personalization variant from the bridge.
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewComponents.swift b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewComponents.swift
index b074749e..8d941985 100644
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewComponents.swift
+++ b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewComponents.swift
@@ -72,6 +72,7 @@ struct PreviewActionButton: View {
     let variant: ActionButtonVariant
     let action: () -> Void
     var disabled: Bool = false
+    var accessibilityID: String? = nil
 
     var body: some View {
         Button(action: action) {
@@ -95,6 +96,7 @@ struct PreviewActionButton: View {
         }
         .disabled(disabled)
         .opacity(disabled ? PreviewTheme.Opacity.disabled : 1)
+        .accessibilityIdentifier(accessibilityID ?? "")
     }
 }
 
@@ -108,6 +110,7 @@ struct AudienceToggle: View {
     let value: AudienceOverrideState
     let onValueChange: (AudienceOverrideState) -> Void
     var disabled: Bool = false
+    var audienceId: String? = nil
 
     private let states: [(AudienceOverrideState, String)] = [
         (.on, "On"),
@@ -131,6 +134,7 @@ struct AudienceToggle: View {
                         )
                 }
                 .disabled(disabled)
+                .accessibilityIdentifier(audienceId.map { "audience-toggle-\($0)-\(state.rawValue)" } ?? "")
             }
         }
         .padding(2)
@@ -346,6 +350,7 @@ struct ListItemRow: View {
     var subtitle: String?
     var badge: (label: String, variant: BadgeVariant)?
     var action: (label: String, variant: ActionButtonVariant, handler: () -> Void)?
+    var actionAccessibilityID: String? = nil
     var onLongPress: (() -> Void)?
 
     var body: some View {
@@ -375,7 +380,12 @@ struct ListItemRow: View {
             Spacer()
 
             if let action = action {
-                PreviewActionButton(label: action.label, variant: action.variant, action: action.handler)
+                PreviewActionButton(
+                    label: action.label,
+                    variant: action.variant,
+                    action: action.handler,
+                    accessibilityID: actionAccessibilityID
+                )
             }
         }
         .padding(.vertical, PreviewTheme.Spacing.sm)
@@ -404,10 +414,12 @@ struct CollapseToggleButton: View {
 // MARK: - Variant Selector
 
 struct VariantSelector: View {
-    let experience: PreviewExperience
+    let experience: ExperienceDefinitionDTO
     let isAudienceActive: Bool
     let onSelectVariant: (Int) -> Void
 
+    private var isExperiment: Bool { experience.type == "nt_experiment" }
+
     var body: some View {
         VStack(spacing: PreviewTheme.Spacing.sm) {
             ForEach(variants, id: \.index) { variant in
@@ -420,7 +432,7 @@ struct VariantSelector: View {
                         }
 
                         // Percentage for experiments
-                        if experience.type == .experiment, let percentage = variant.percentage {
+                        if isExperiment, let percentage = variant.percentage {
                             Text("\(percentage)%")
                                 .font(.system(size: PreviewTheme.FontSize.sm))
                                 .foregroundColor(PreviewTheme.Colors.TextColor.muted)
@@ -464,21 +476,22 @@ struct VariantSelector: View {
                 }
                 .buttonStyle(.plain)
                 .opacity(isAudienceActive ? 1.0 : PreviewTheme.Opacity.muted)
+                .accessibilityIdentifier("variant-picker-\(experience.id)-\(variant.index)")
             }
         }
     }
 
     /// Use distribution data if available, otherwise generate from current variant index.
-    private var variants: [VariantDistribution] {
+    private var variants: [VariantDistributionDTO] {
         if !experience.distribution.isEmpty {
             return experience.distribution
         }
         // Fallback: generate basic variant list
         let count = max(experience.currentVariantIndex + 1, 2)
-        return (0..<count).map { VariantDistribution(index: $0, variantRef: "", percentage: nil, name: nil) }
+        return (0..<count).map { VariantDistributionDTO(index: $0, variantRef: "", percentage: nil, name: nil) }
     }
 
-    private func variantLabel(for variant: VariantDistribution) -> String {
+    private func variantLabel(for variant: VariantDistributionDTO) -> String {
         if let name = variant.name, !name.isEmpty {
             return name
         }
@@ -489,17 +502,19 @@ struct VariantSelector: View {
 // MARK: - Experience Card
 
 struct ExperienceCard: View {
-    let experience: PreviewExperience
+    let experience: ExperienceDefinitionDTO
     let isAudienceActive: Bool
     let onSelectVariant: (Int) -> Void
 
+    private var isExperiment: Bool { experience.type == "nt_experiment" }
+
     var body: some View {
         VStack(alignment: .leading, spacing: PreviewTheme.Spacing.sm) {
             // Header with type badge and override badge
             HStack(spacing: PreviewTheme.Spacing.sm) {
                 PreviewBadge(
-                    label: experience.type == .experiment ? "Experiment" : "Personalization",
-                    variant: experience.type == .experiment ? .experiment : .personalization
+                    label: isExperiment ? "Experiment" : "Personalization",
+                    variant: isExperiment ? .experiment : .personalization
                 )
                 if experience.isOverridden {
                     PreviewBadge(label: "Override", variant: .override_)
@@ -535,12 +550,16 @@ struct ExperienceCard: View {
 // MARK: - Audience Item Header
 
 struct AudienceItemHeader: View {
-    let audience: PreviewAudience
+    let audience: AudienceWithExperiencesDTO
     let isExpanded: Bool
     let onToggleExpand: () -> Void
     let onToggleOverride: (AudienceOverrideState) -> Void
     let onCopyId: () -> Void
 
+    private var overrideState: AudienceOverrideState {
+        AudienceOverrideState(rawValue: audience.overrideState) ?? .default
+    }
+
     var body: some View {
         VStack(alignment: .leading, spacing: PreviewTheme.Spacing.sm) {
             // Name row with qualification indicator
@@ -550,7 +569,7 @@ struct AudienceItemHeader: View {
                         .font(.system(size: PreviewTheme.FontSize.xl))
                         .foregroundColor(PreviewTheme.Colors.CP.hover)
 
-                    Text(audience.name)
+                    Text(audience.audience.name)
                         .font(.system(size: PreviewTheme.FontSize.sm, weight: .medium))
                         .foregroundColor(PreviewTheme.Colors.TextColor.primary)
                         .lineLimit(1)
@@ -571,7 +590,7 @@ struct AudienceItemHeader: View {
             .onLongPressGesture(minimumDuration: 0.5, perform: onCopyId)
 
             // Description
-            if let description = audience.description, !description.isEmpty {
+            if let description = audience.audience.description, !description.isEmpty {
                 Text(description)
                     .font(.system(size: PreviewTheme.FontSize.xs))
                     .foregroundColor(PreviewTheme.Colors.TextColor.secondary)
@@ -579,8 +598,9 @@ struct AudienceItemHeader: View {
 
             // Toggle row
             AudienceToggle(
-                value: audience.overrideState,
-                onValueChange: onToggleOverride
+                value: overrideState,
+                onValueChange: onToggleOverride,
+                audienceId: audience.audience.id
             )
         }
         .padding(.horizontal, PreviewTheme.Spacing.md)
@@ -591,7 +611,7 @@ struct AudienceItemHeader: View {
 // MARK: - Audience Item
 
 struct AudienceItem: View {
-    let audience: PreviewAudience
+    let audience: AudienceWithExperiencesDTO
     let isExpanded: Bool
     let onToggleExpand: () -> Void
     let onToggleOverride: (AudienceOverrideState) -> Void
@@ -610,7 +630,7 @@ struct AudienceItem: View {
 
             if isExpanded {
                 VStack(spacing: PreviewTheme.Spacing.sm) {
-                    ForEach(audience.experiences) { experience in
+                    ForEach(audience.experiences, id: \.id) { experience in
                         ExperienceCard(
                             experience: experience,
                             isAudienceActive: audience.isQualified,
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewDefinitions.swift b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewDefinitions.swift
deleted file mode 100644
index 6b444381..00000000
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewDefinitions.swift
+++ /dev/null
@@ -1,217 +0,0 @@
-import Foundation
-
-// MARK: - Constants
-
-let allVisitorsAudienceId = "ALL_VISITORS"
-let allVisitorsAudienceName = "All Visitors"
-let allVisitorsAudienceDescription = "Experiences that apply to all visitors regardless of audience membership"
-
-// MARK: - Definition Types (from Contentful entries)
-
-enum ExperienceType: String {
-    case personalization = "nt_personalization"
-    case experiment = "nt_experiment"
-}
-
-struct AudienceDefinition {
-    let id: String
-    let name: String
-    let description: String?
-}
-
-struct VariantDistribution {
-    let index: Int
-    let variantRef: String
-    let percentage: Int?
-    let name: String?
-}
-
-struct ExperienceDefinition: Identifiable {
-    let id: String
-    let name: String
-    let type: ExperienceType
-    let distribution: [VariantDistribution]
-    let audienceId: String?
-}
-
-// MARK: - Display Models (combined definitions + SDK state)
-
-struct PreviewAudience: Identifiable {
-    let id: String
-    let name: String
-    let description: String?
-    var isQualified: Bool
-    var isActive: Bool
-    var experiences: [PreviewExperience]
-    var overrideState: AudienceOverrideState
-}
-
-struct PreviewExperience: Identifiable {
-    let id: String
-    let name: String
-    let type: ExperienceType
-    var distribution: [VariantDistribution]
-    var currentVariantIndex: Int
-    var isOverridden: Bool
-    var naturalVariantIndex: Int?
-}
-
-// MARK: - Entry Mappers
-
-/// Creates audience definitions from Contentful `nt_audience` entries.
-/// Matches RN `createAudienceDefinitions` in entryMappers.ts.
-func createAudienceDefinitions(from entries: [[String: Any]]) -> [AudienceDefinition] {
-    entries.compactMap { entry in
-        let fields = entry["fields"] as? [String: Any] ?? [:]
-        let sysId = (entry["sys"] as? [String: Any])?["id"] as? String ?? ""
-
-        let id = fields["nt_audience_id"] as? String ?? sysId
-        let name = fields["nt_name"] as? String ?? id
-        let description = fields["nt_description"] as? String
-
-        return AudienceDefinition(id: id, name: name, description: description)
-    }
-}
-
-/// Creates experience definitions from Contentful `nt_experience` entries.
-/// Matches RN `createExperienceDefinitions` in entryMappers.ts.
-func createExperienceDefinitions(from entries: [[String: Any]], includedEntries: [[String: Any]]) -> [ExperienceDefinition] {
-    // Build variant entry map for name resolution
-    let variantEntryMap = buildVariantEntryMap(from: includedEntries)
-
-    return entries.compactMap { entry in
-        let fields = entry["fields"] as? [String: Any] ?? [:]
-        let sysId = (entry["sys"] as? [String: Any])?["id"] as? String ?? ""
-
-        let id = fields["nt_experience_id"] as? String ?? sysId
-        let name = fields["nt_name"] as? String ?? sysId
-        let typeStr = fields["nt_type"] as? String ?? "nt_personalization"
-        let type = ExperienceType(rawValue: typeStr) ?? .personalization
-
-        // Extract audience link
-        let audienceLink = fields["nt_audience"] as? [String: Any]
-        let audienceSys = audienceLink?["sys"] as? [String: Any]
-        let audienceId = audienceSys?["id"] as? String
-
-        // Extract distribution from config
-        let config = fields["nt_config"] as? [String: Any]
-        let distribution = extractDistribution(from: config, variantEntryMap: variantEntryMap)
-
-        return ExperienceDefinition(
-            id: id,
-            name: name,
-            type: type,
-            distribution: distribution,
-            audienceId: audienceId
-        )
-    }
-}
-
-/// Creates a name lookup map from experience entries: experienceId → name.
-func createExperienceNameMap(from entries: [[String: Any]]) -> [String: String] {
-    var map: [String: String] = [:]
-    for entry in entries {
-        let fields = entry["fields"] as? [String: Any] ?? [:]
-        let sysId = (entry["sys"] as? [String: Any])?["id"] as? String ?? ""
-        let id = fields["nt_experience_id"] as? String ?? sysId
-        let name = fields["nt_name"] as? String ?? sysId
-        map[id] = name
-    }
-    return map
-}
-
-/// Creates a name lookup map from audience entries: audienceId → name.
-func createAudienceNameMap(from definitions: [AudienceDefinition]) -> [String: String] {
-    var map: [String: String] = [:]
-    for def in definitions {
-        map[def.id] = def.name
-    }
-    return map
-}
-
-// MARK: - Distribution Extraction
-
-/// Extracts variant distribution from an experience config.
-/// Matches RN `extractDistributionFromConfig` in entryMappers.ts.
-private func extractDistribution(from config: [String: Any]?, variantEntryMap: [String: [String: Any]]) -> [VariantDistribution] {
-    guard let config = config else { return [] }
-
-    let percentages = config["distribution"] as? [Any] ?? []
-    let components = config["components"] as? [[String: Any]] ?? []
-    guard let firstComponent = components.first else { return [] }
-
-    var variants: [VariantDistribution] = []
-
-    // Baseline (index 0)
-    if let baseline = firstComponent["baseline"] as? [String: Any],
-       let baselineId = baseline["id"] as? String {
-        let percentage = percentages.first.flatMap { asInt($0) }
-        let name = resolveVariantName(variantRef: baselineId, variantEntryMap: variantEntryMap)
-        variants.append(VariantDistribution(index: 0, variantRef: baselineId, percentage: percentage, name: name))
-    }
-
-    // Variants (index 1+)
-    let variantRefs = firstComponent["variants"] as? [[String: Any]] ?? []
-    for (i, variantRef) in variantRefs.enumerated() {
-        guard let variantId = variantRef["id"] as? String else { continue }
-        let hidden = variantRef["hidden"] as? Bool ?? false
-        if hidden { continue }
-
-        let percentageIndex = i + 1
-        let rawPercentage = percentageIndex < percentages.count ? percentages[percentageIndex] : nil
-        let percentage = rawPercentage.flatMap { asPercentage($0) }
-        let name = resolveVariantName(variantRef: variantId, variantEntryMap: variantEntryMap)
-
-        variants.append(VariantDistribution(
-            index: i + 1,
-            variantRef: variantId,
-            percentage: percentage,
-            name: name
-        ))
-    }
-
-    return variants
-}
-
-// MARK: - Variant Name Resolution
-
-/// Builds a map from entry sys.id to the full entry object for name resolution.
-private func buildVariantEntryMap(from includedEntries: [[String: Any]]) -> [String: [String: Any]] {
-    var map: [String: [String: Any]] = [:]
-    for entry in includedEntries {
-        if let sys = entry["sys"] as? [String: Any],
-           let id = sys["id"] as? String {
-            map[id] = entry
-        }
-    }
-    return map
-}
-
-/// Resolves a variant name from an included entry.
-/// Checks fields: internalTitle → title → name (matching RN `getVariantName`).
-private func resolveVariantName(variantRef: String, variantEntryMap: [String: [String: Any]]) -> String? {
-    guard let entry = variantEntryMap[variantRef],
-          let fields = entry["fields"] as? [String: Any]
-    else { return nil }
-
-    if let name = fields["internalTitle"] as? String, !name.isEmpty { return name }
-    if let name = fields["title"] as? String, !name.isEmpty { return name }
-    if let name = fields["name"] as? String, !name.isEmpty { return name }
-    return nil
-}
-
-// MARK: - Helpers
-
-private func asInt(_ value: Any) -> Int? {
-    if let n = value as? Int { return n }
-    if let n = value as? Double { return Int(round(n * 100)) }
-    if let n = value as? NSNumber { return Int(round(n.doubleValue * 100)) }
-    return nil
-}
-
-private func asPercentage(_ value: Any) -> Int? {
-    if let n = value as? Double { return Int(round(n * 100)) }
-    if let n = value as? NSNumber { return Int(round(n.doubleValue * 100)) }
-    if let n = value as? Int { return n }
-    return nil
-}
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewPanelContent.swift b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewPanelContent.swift
index 2930eb50..c8ee04ab 100644
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewPanelContent.swift
+++ b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Preview/PreviewPanelContent.swift
@@ -1,34 +1,28 @@
 import Combine
 import SwiftUI
 
+/// ID used by core's `buildPreviewModel` to bucket experiences that don't
+/// target any defined audience.
+let allVisitorsAudienceId = "ALL_VISITORS"
+
 // MARK: - View Model
 
+/// Thin UI-state holder. All bridge-derived data is observed directly from
+/// ``OptimizationClient/previewState``; the view model owns only genuinely
+/// iOS-side concerns (search text, expansion state, async-fetch flags) plus
+/// action delegation.
 @MainActor
 final class PreviewViewModel: ObservableObject {
     let client: OptimizationClient
     let contentfulClient: PreviewContentfulClient?
 
-    @Published var audiences: [PreviewAudience] = []
-    @Published var profile: [String: Any]?
-    @Published var consent: Bool?
-    @Published var canPersonalize: Bool = false
     @Published var searchQuery: String = ""
     @Published var expandedAudiences: Set<String> = []
     @Published var isLoadingDefinitions: Bool = false
     @Published var definitionsError: String?
 
-    // Definitions from Contentful
-    private var audienceDefinitions: [AudienceDefinition] = []
-    private var experienceDefinitions: [ExperienceDefinition] = []
-    private var audienceNameMap: [String: String] = [:]
-    private var experienceNameMap: [String: String] = [:]
     private var hasLoadedDefinitions = false
 
-    // Override state read from the JS bridge (single source of truth)
-    private var bridgeAudienceOverrides: [String: Bool] = [:]
-    private var bridgeVariantOverrides: [String: Int] = [:]
-    private var bridgeDefaultVariantIndices: [String: Int] = [:]
-
     init(client: OptimizationClient, contentfulClient: PreviewContentfulClient? = nil) {
         self.client = client
         self.contentfulClient = contentfulClient
@@ -45,264 +39,45 @@ final class PreviewViewModel: ObservableObject {
         do {
             let results = try await fetchAudienceAndExperienceEntries(client: contentfulClient)
 
-            audienceDefinitions = createAudienceDefinitions(from: results.audiences.items)
-            experienceDefinitions = createExperienceDefinitions(
-                from: results.experiences.items,
-                includedEntries: results.experiences.includes.entries
+            // Embed per-entry includes so JS `buildVariantEntryMap` can resolve
+            // variant entry names from linked references. Contentful CDA returns
+            // includes at the top level; JS expects them nested under each entry.
+            let experienceEntriesWithIncludes: [[String: Any]] = results.experiences.items.map { item in
+                var copy = item
+                copy["includes"] = ["Entry": results.experiences.includes.entries]
+                return copy
+            }
+
+            try client.loadDefinitions(
+                audiences: results.audiences.items,
+                experiences: experienceEntriesWithIncludes
             )
-            audienceNameMap = createAudienceNameMap(from: audienceDefinitions)
-            experienceNameMap = createExperienceNameMap(from: results.experiences.items)
+
             hasLoadedDefinitions = true
             isLoadingDefinitions = false
-
-            // Rebuild audiences with rich data
-            refreshState()
         } catch {
             definitionsError = error.localizedDescription
             isLoadingDefinitions = false
         }
     }
 
-    // MARK: - State Management
-
-    func refreshState() {
-        guard let state = client.getPreviewState() else { return }
-
-        profile = state.profile?.toFoundation() as? [String: Any]
-        consent = state.consent
-        canPersonalize = state.canPersonalize
-
-        // Read override tracking from the bridge (single source of truth)
-        bridgeAudienceOverrides = state.audienceOverrides ?? [:]
-        bridgeVariantOverrides = state.variantOverrides ?? [:]
-        bridgeDefaultVariantIndices = state.defaultVariantIndices ?? [:]
-
-        let selectedPersonalizations = state.selectedPersonalizations ?? []
-        let changes = state.changes ?? []
-        let qualifiedAudienceIds = Set(state.profile?["audiences"]?.toStringArray() ?? [])
-
-        // Build experience variant lookup from selectedPersonalizations
-        var sdkVariantIndices: [String: Int] = [:]
-        for p in selectedPersonalizations {
-            sdkVariantIndices[p.experienceId] = p.variantIndex
-        }
-
-        if hasLoadedDefinitions {
-            buildAudiencesFromDefinitions(
-                changes: changes,
-                sdkVariantIndices: sdkVariantIndices,
-                qualifiedAudienceIds: qualifiedAudienceIds
-            )
-        } else {
-            buildAudiencesFromChanges(
-                changes: changes,
-                sdkVariantIndices: sdkVariantIndices,
-                selectedPersonalizations: selectedPersonalizations
-            )
-        }
-    }
-
-    /// Derive the AudienceOverrideState for a given audience from the bridge's override map.
-    private func audienceOverrideState(for audienceId: String) -> AudienceOverrideState {
-        guard let qualified = bridgeAudienceOverrides[audienceId] else {
-            return .default
-        }
-        return qualified ? .on : .off
-    }
-
-    // MARK: - Build Audiences from Contentful Definitions (rich data)
-
-    private func buildAudiencesFromDefinitions(
-        changes: [PreviewChange],
-        sdkVariantIndices: [String: Int],
-        qualifiedAudienceIds: Set<String>
-    ) {
-        let audienceIds = Set(audienceDefinitions.map(\.id))
-
-        // Find experiences not associated with any defined audience
-        let unassociatedExperiences = experienceDefinitions.filter { exp in
-            guard let audienceId = exp.audienceId else { return true }
-            return !audienceIds.contains(audienceId)
-        }
-
-        // Build change qualification lookup
-        var changeQualification: [String: Bool] = [:]
-        for change in changes {
-            if let audienceId = change.audienceId,
-               let qualified = change.qualified {
-                changeQualification[audienceId] = qualified
-            }
-        }
-
-        var result: [PreviewAudience] = []
-
-        for audienceDef in audienceDefinitions {
-            let experiences = experienceDefinitions.filter { $0.audienceId == audienceDef.id }
-            guard !experiences.isEmpty else { continue }
-
-            let isQualified = qualifiedAudienceIds.contains(audienceDef.id)
-            let overrideState = audienceOverrideState(for: audienceDef.id)
-            let isActive: Bool
-            switch overrideState {
-            case .on: isActive = true
-            case .off: isActive = false
-            case .default: isActive = changeQualification[audienceDef.id] ?? isQualified
-            }
-
-            let previewExperiences = experiences.map { exp -> PreviewExperience in
-                let currentVariant = sdkVariantIndices[exp.id] ?? 0
-                let isOverridden = bridgeVariantOverrides[exp.id] != nil
-                let naturalVariant = bridgeDefaultVariantIndices[exp.id]
-
-                return PreviewExperience(
-                    id: exp.id,
-                    name: exp.name,
-                    type: exp.type,
-                    distribution: exp.distribution,
-                    currentVariantIndex: currentVariant,
-                    isOverridden: isOverridden,
-                    naturalVariantIndex: naturalVariant
-                )
-            }
-
-            result.append(PreviewAudience(
-                id: audienceDef.id,
-                name: audienceDef.name,
-                description: audienceDef.description,
-                isQualified: isQualified,
-                isActive: isActive,
-                experiences: previewExperiences,
-                overrideState: overrideState
-            ))
-        }
-
-        // Add "All Visitors" for unassociated experiences
-        if !unassociatedExperiences.isEmpty {
-            let allVisitorsOverride = audienceOverrideState(for: allVisitorsAudienceId)
-            let previewExperiences = unassociatedExperiences.map { exp -> PreviewExperience in
-                let currentVariant = sdkVariantIndices[exp.id] ?? 0
-                return PreviewExperience(
-                    id: exp.id,
-                    name: exp.name,
-                    type: exp.type,
-                    distribution: exp.distribution,
-                    currentVariantIndex: currentVariant,
-                    isOverridden: bridgeVariantOverrides[exp.id] != nil,
-                    naturalVariantIndex: bridgeDefaultVariantIndices[exp.id]
-                )
-            }
-
-            result.insert(PreviewAudience(
-                id: allVisitorsAudienceId,
-                name: allVisitorsAudienceName,
-                description: allVisitorsAudienceDescription,
-                isQualified: true,
-                isActive: true,
-                experiences: previewExperiences,
-                overrideState: allVisitorsOverride
-            ), at: 0)
-        }
-
-        // Sort: qualified first, then alphabetically
-        result.sort { a, b in
-            if a.id == allVisitorsAudienceId { return true }
-            if b.id == allVisitorsAudienceId { return false }
-            if a.isQualified != b.isQualified { return a.isQualified }
-            return a.name.localizedCaseInsensitiveCompare(b.name) == .orderedAscending
-        }
-
-        audiences = result
-    }
-
-    // MARK: - Build Audiences from Changes (fallback without Contentful)
-
-    private func buildAudiencesFromChanges(
-        changes: [PreviewChange],
-        sdkVariantIndices: [String: Int],
-        selectedPersonalizations: [SelectedPersonalization]
-    ) {
-        var audienceMap: [String: (name: String, qualified: Bool, experiences: [String: Int])] = [:]
-        for change in changes {
-            guard let audienceId = change.audienceId else { continue }
-            let name = change.name ?? audienceId
-            let qualified = change.qualified ?? false
-
-            var entry = audienceMap[audienceId] ?? (name: name, qualified: qualified, experiences: [:])
-            entry.qualified = qualified
-            entry.name = name
-
-            if let expId = change.meta?.experienceId {
-                let variant = sdkVariantIndices[expId] ?? (change.meta?.variantIndex ?? 0)
-                entry.experiences[expId] = variant
-            }
-            audienceMap[audienceId] = entry
-        }
-
-        // Add experiences from selectedPersonalizations not in any audience
-        for p in selectedPersonalizations {
-            let found = audienceMap.values.contains { $0.experiences.keys.contains(p.experienceId) }
-            if !found {
-                var entry = audienceMap[allVisitorsAudienceId] ?? (name: allVisitorsAudienceName, qualified: true, experiences: [:])
-                entry.experiences[p.experienceId] = p.variantIndex
-                audienceMap[allVisitorsAudienceId] = entry
-            }
-        }
-
-        audiences = audienceMap.map { audienceId, data in
-            let overrideState = audienceOverrideState(for: audienceId)
-            let experiences = data.experiences.map { expId, variant in
-                let isOverridden = bridgeVariantOverrides[expId] != nil
-                let naturalVariant = bridgeDefaultVariantIndices[expId]
-                let distribution: [VariantDistribution]
-                let maxCount = max(variant + 1, naturalVariant.map { $0 + 1 } ?? 0, 2)
-                distribution = (0..<maxCount).map { VariantDistribution(index: $0, variantRef: "", percentage: nil, name: nil) }
-
-                return PreviewExperience(
-                    id: expId,
-                    name: experienceNameMap[expId] ?? expId,
-                    type: .personalization,
-                    distribution: distribution,
-                    currentVariantIndex: variant,
-                    isOverridden: isOverridden,
-                    naturalVariantIndex: naturalVariant
-                )
-            }.sorted { $0.id < $1.id }
-
-            return PreviewAudience(
-                id: audienceId,
-                name: data.name,
-                description: nil,
-                isQualified: data.qualified,
-                isActive: data.qualified,
-                experiences: experiences,
-                overrideState: overrideState
-            )
-        }
-
-        audiences.sort { a, b in
-            if a.id == allVisitorsAudienceId { return true }
-            if b.id == allVisitorsAudienceId { return false }
-            if a.isQualified != b.isQualified { return a.isQualified }
-            return a.name.localizedCaseInsensitiveCompare(b.name) == .orderedAscending
-        }
-    }
-
     // MARK: - Filtering
 
-    var filteredAudiences: [PreviewAudience] {
+    func filteredAudiences(from model: PreviewModelDTO?) -> [AudienceWithExperiencesDTO] {
+        let audiences = model?.audiencesWithExperiences ?? []
         guard !searchQuery.isEmpty else { return audiences }
         let query = searchQuery.lowercased()
-        return audiences.filter { audience in
-            audience.name.lowercased().contains(query) ||
-            (audience.description?.lowercased().contains(query) ?? false) ||
-            audience.experiences.contains { $0.name.lowercased().contains(query) }
+        return audiences.filter { dto in
+            dto.audience.name.lowercased().contains(query)
+                || (dto.audience.description?.lowercased().contains(query) ?? false)
+                || dto.experiences.contains { $0.name.lowercased().contains(query) }
         }
     }
 
     // MARK: - Expand/Collapse
 
-    var allExpanded: Bool {
-        !filteredAudiences.isEmpty && filteredAudiences.allSatisfy { expandedAudiences.contains($0.id) }
+    func allExpanded(for audiences: [AudienceWithExperiencesDTO]) -> Bool {
+        !audiences.isEmpty && audiences.allSatisfy { expandedAudiences.contains($0.audience.id) }
     }
 
     func toggleExpand(_ audienceId: String) {
@@ -315,96 +90,47 @@ final class PreviewViewModel: ObservableObject {
         }
     }
 
-    func toggleExpandAll() {
+    func toggleExpandAll(for audiences: [AudienceWithExperiencesDTO]) {
         withAnimation(.easeInOut(duration: 0.25)) {
-            if allExpanded {
+            if allExpanded(for: audiences) {
                 expandedAudiences.removeAll()
             } else {
-                expandedAudiences = Set(filteredAudiences.map(\.id))
+                expandedAudiences = Set(audiences.map(\.audience.id))
             }
         }
     }
 
     // MARK: - Override Actions
 
-    func setAudienceOverride(audienceId: String, state: AudienceOverrideState) {
+    func setAudienceOverride(
+        audienceId: String,
+        state: AudienceOverrideState,
+        experienceIds: [String]
+    ) {
         switch state {
         case .on:
-            client.overrideAudience(id: audienceId, qualified: true)
-            if let audience = audiences.first(where: { $0.id == audienceId }) {
-                for experience in audience.experiences {
-                    if bridgeVariantOverrides[experience.id] == nil {
-                        client.overrideVariant(experienceId: experience.id, variantIndex: 1)
-                    }
-                }
-            }
+            client.overrideAudience(id: audienceId, qualified: true, experienceIds: experienceIds)
         case .off:
-            client.overrideAudience(id: audienceId, qualified: false)
-            if let audience = audiences.first(where: { $0.id == audienceId }) {
-                for experience in audience.experiences {
-                    client.overrideVariant(experienceId: experience.id, variantIndex: 0)
-                }
-            }
+            client.overrideAudience(id: audienceId, qualified: false, experienceIds: experienceIds)
         case .default:
             client.resetAudienceOverride(id: audienceId)
-            if let audience = audiences.first(where: { $0.id == audienceId }) {
-                for experience in audience.experiences {
-                    client.resetVariantOverride(experienceId: experience.id)
-                }
-            }
         }
-
-        refreshState()
     }
 
     func setVariantOverride(experienceId: String, variantIndex: Int) {
         client.overrideVariant(experienceId: experienceId, variantIndex: variantIndex)
-        refreshState()
     }
 
     func resetAudienceOverride(audienceId: String) {
-        setAudienceOverride(audienceId: audienceId, state: .default)
+        client.resetAudienceOverride(id: audienceId)
     }
 
     func resetVariantOverride(experienceId: String) {
         client.resetVariantOverride(experienceId: experienceId)
-        refreshState()
     }
 
     func resetAllOverrides() {
         client.resetAllOverrides()
-        refreshState()
-    }
-
-    // MARK: - Override Summary
-
-    var audienceOverrideCount: Int {
-        bridgeAudienceOverrides.count
-    }
-
-    var variantOverrideCount: Int {
-        bridgeVariantOverrides.count
-    }
-
-    var hasOverrides: Bool {
-        audienceOverrideCount > 0 || variantOverrideCount > 0
-    }
-
-    var activeAudienceOverrides: [(id: String, name: String, state: AudienceOverrideState)] {
-        bridgeAudienceOverrides.map { audienceId, qualified in
-            let name = audienceNameMap[audienceId]
-                ?? audiences.first(where: { $0.id == audienceId })?.name
-                ?? audienceId
-            let state: AudienceOverrideState = qualified ? .on : .off
-            return (id: audienceId, name: name, state: state)
-        }.sorted { $0.name < $1.name }
-    }
-
-    var activeVariantOverrides: [(experienceId: String, name: String, variantIndex: Int)] {
-        bridgeVariantOverrides.map { expId, variant in
-            let name = experienceNameMap[expId] ?? expId
-            return (experienceId: expId, name: name, variantIndex: variant)
-        }.sorted { $0.name < $1.name }
     }
 
     // MARK: - Clipboard
@@ -438,16 +164,18 @@ public struct PreviewPanelContent: View {
             }
         }
         .onAppear {
+            // Pull the current bridge snapshot so the panel never renders a blank
+            // initial state. `client.previewState` only updates when the JS side
+            // fires `notifyChanged` — which happens on API refreshes and override
+            // mutations, neither of which may have occurred by the time the user
+            // opens the panel for the first time.
+            client.refreshPreviewState()
             if viewModel == nil {
                 let vm = PreviewViewModel(client: client, contentfulClient: contentfulClient)
                 viewModel = vm
-                vm.refreshState()
                 Task { await vm.loadDefinitions() }
             }
         }
-        .onReceive(client.$state) { _ in
-            viewModel?.refreshState()
-        }
     }
 }
 
@@ -455,15 +183,27 @@ public struct PreviewPanelContent: View {
 
 struct PreviewPanelMain: View {
     @ObservedObject var viewModel: PreviewViewModel
+    @EnvironmentObject private var client: OptimizationClient
     @State private var showResetAlert = false
 
+    private var previewModel: PreviewModelDTO? { client.previewState?.previewModel }
+    private var audienceOverrides: [String: Bool] { client.previewState?.audienceOverrides ?? [:] }
+    private var variantOverrides: [String: Int] { client.previewState?.variantOverrides ?? [:] }
+    private var audienceNameMap: [String: String] { previewModel?.audienceNameMap ?? [:] }
+    private var experienceNameMap: [String: String] { previewModel?.experienceNameMap ?? [:] }
+    private var hasOverrides: Bool { !audienceOverrides.isEmpty || !variantOverrides.isEmpty }
+
+    private var filteredAudiences: [AudienceWithExperiencesDTO] {
+        viewModel.filteredAudiences(from: previewModel)
+    }
+
     var body: some View {
         VStack(spacing: 0) {
             panelHeader
                 .padding(.horizontal, PreviewTheme.Spacing.lg)
                 .padding(.vertical, PreviewTheme.Spacing.md)
 
-            if !viewModel.audiences.isEmpty {
+            if !(previewModel?.audiencesWithExperiences.isEmpty ?? true) {
                 PreviewSearchBar(text: $viewModel.searchQuery)
                     .padding(.horizontal, PreviewTheme.Spacing.lg)
                     .padding(.bottom, PreviewTheme.Spacing.md)
@@ -471,7 +211,6 @@ struct PreviewPanelMain: View {
 
             ScrollView {
                 VStack(spacing: PreviewTheme.Spacing.lg) {
-                    // Loading indicator for definitions
                     if viewModel.isLoadingDefinitions {
                         HStack(spacing: PreviewTheme.Spacing.sm) {
                             ProgressView()
@@ -500,11 +239,13 @@ struct PreviewPanelMain: View {
 
                     audienceSection
                     profileSection
+                    debugSection
                     overridesSection
                 }
                 .padding(.horizontal, PreviewTheme.Spacing.lg)
                 .padding(.bottom, PreviewTheme.Spacing.lg)
             }
+            .accessibilityIdentifier("preview-panel-list")
 
             panelFooter
         }
@@ -536,25 +277,25 @@ struct PreviewPanelMain: View {
     }
 
     private var consentText: String {
-        guard let consent = viewModel.consent else { return "—" }
+        guard let consent = client.previewState?.consent else { return "—" }
         return consent ? "Yes" : "No"
     }
 
     // MARK: - Audience Section
 
     private var audienceSection: some View {
-        SectionCard(title: "Audiences & Experiences (\(viewModel.filteredAudiences.count))") {
-            if viewModel.filteredAudiences.count > 1 {
+        SectionCard(title: "Audiences & Experiences (\(filteredAudiences.count))") {
+            if filteredAudiences.count > 1 {
                 HStack {
                     Spacer()
                     CollapseToggleButton(
-                        allExpanded: viewModel.allExpanded,
-                        onToggle: { viewModel.toggleExpandAll() }
+                        allExpanded: viewModel.allExpanded(for: filteredAudiences),
+                        onToggle: { viewModel.toggleExpandAll(for: filteredAudiences) }
                     )
                 }
             }
 
-            if viewModel.filteredAudiences.isEmpty {
+            if filteredAudiences.isEmpty {
                 if viewModel.searchQuery.isEmpty {
                     Text("No audience data")
                         .font(.system(size: PreviewTheme.FontSize.sm))
@@ -570,20 +311,24 @@ struct PreviewPanelMain: View {
                 }
             } else {
                 VStack(spacing: PreviewTheme.Spacing.sm) {
-                    ForEach(viewModel.filteredAudiences) { audience in
+                    ForEach(filteredAudiences, id: \.audience.id) { audience in
                         AudienceItem(
                             audience: audience,
-                            isExpanded: viewModel.expandedAudiences.contains(audience.id),
-                            onToggleExpand: { viewModel.toggleExpand(audience.id) },
+                            isExpanded: viewModel.expandedAudiences.contains(audience.audience.id),
+                            onToggleExpand: { viewModel.toggleExpand(audience.audience.id) },
                             onToggleOverride: { state in
-                                viewModel.setAudienceOverride(audienceId: audience.id, state: state)
+                                viewModel.setAudienceOverride(
+                                    audienceId: audience.audience.id,
+                                    state: state,
+                                    experienceIds: audience.experiences.map(\.id)
+                                )
                             },
                             onSelectVariant: { expId, variant in
                                 viewModel.setVariantOverride(experienceId: expId, variantIndex: variant)
                             },
                             onCopyId: {
                                 #if canImport(UIKit)
-                                viewModel.copyToClipboard(audience.id, label: "Audience ID")
+                                viewModel.copyToClipboard(audience.audience.id, label: "Audience ID")
                                 #endif
                             }
                         )
@@ -591,15 +336,34 @@ struct PreviewPanelMain: View {
                 }
             }
         }
-        .accessibilityIdentifier("preview-panel-list")
     }
 
     // MARK: - Profile Section
 
     private var profileSection: some View {
-        SectionCard(title: "Profile", collapsible: true, initiallyCollapsed: true) {
-            if let profile = viewModel.profile {
+        SectionCard(title: "Profile", collapsible: true, initiallyCollapsed: false) {
+            if let profile = client.previewState?.profile?.toFoundation() as? [String: Any] {
                 VStack(alignment: .leading, spacing: PreviewTheme.Spacing.md) {
+                    // Flat per-key rows keep the profile shape test-addressable via
+                    // `profile-item-<key>` identifiers — matches the shared contract
+                    // the XCUITest suite drives.
+                    ForEach(Array(profile.keys.sorted()), id: \.self) { key in
+                        HStack(alignment: .top) {
+                            Text(key)
+                                .font(.system(size: PreviewTheme.FontSize.xs, weight: .semibold))
+                                .foregroundColor(PreviewTheme.Colors.TextColor.primary)
+                            Spacer()
+                            Text(stringValue(profile[key]))
+                                .font(.system(size: PreviewTheme.FontSize.xs))
+                                .foregroundColor(PreviewTheme.Colors.TextColor.secondary)
+                                .lineLimit(2)
+                                .multilineTextAlignment(.trailing)
+                        }
+                        .accessibilityElement(children: .combine)
+                        .accessibilityIdentifier("profile-item-\(key)")
+                    }
+                    Divider()
+
                     if let profileId = profile["id"] as? String {
                         ListItemRow(
                             label: "Profile ID",
@@ -664,27 +428,85 @@ struct PreviewPanelMain: View {
                     .foregroundColor(PreviewTheme.Colors.TextColor.muted)
                     .frame(maxWidth: .infinity, alignment: .center)
                     .padding(.vertical, PreviewTheme.Spacing.lg)
+                    .accessibilityIdentifier("no-profile-data")
             }
         }
     }
 
+    // MARK: - Debug Section
+
+    private var debugSection: some View {
+        SectionCard(title: "Debug", collapsible: true) {
+            VStack(alignment: .leading, spacing: PreviewTheme.Spacing.md) {
+                HStack {
+                    Text("Consent")
+                        .font(.system(size: PreviewTheme.FontSize.sm, weight: .medium))
+                        .foregroundColor(PreviewTheme.Colors.TextColor.primary)
+                    Spacer()
+                    Text(consentLabel)
+                        .font(.system(size: PreviewTheme.FontSize.sm))
+                        .foregroundColor(PreviewTheme.Colors.TextColor.secondary)
+                }
+                .accessibilityElement(children: .combine)
+                .accessibilityIdentifier("debug-consent")
+
+                HStack {
+                    Text("Can Personalize")
+                        .font(.system(size: PreviewTheme.FontSize.sm, weight: .medium))
+                        .foregroundColor(PreviewTheme.Colors.TextColor.primary)
+                    Spacer()
+                    Text(canPersonalizeLabel)
+                        .font(.system(size: PreviewTheme.FontSize.sm))
+                        .foregroundColor(PreviewTheme.Colors.TextColor.secondary)
+                }
+                .accessibilityElement(children: .combine)
+                .accessibilityIdentifier("debug-can-personalize")
+
+                Button(action: { client.refreshPreviewState() }) {
+                    Text("Refresh")
+                        .font(.system(size: PreviewTheme.FontSize.sm, weight: .semibold))
+                        .foregroundColor(PreviewTheme.Colors.TextColor.inverse)
+                        .frame(maxWidth: .infinity)
+                        .padding(.vertical, PreviewTheme.Spacing.sm)
+                        .background(
+                            RoundedRectangle(cornerRadius: PreviewTheme.Radius.md)
+                                .fill(PreviewTheme.Colors.CP.normal)
+                        )
+                }
+                .accessibilityIdentifier("preview-refresh-button")
+            }
+        }
+    }
+
+    private var consentLabel: String {
+        switch client.previewState?.consent {
+        case .some(true): return "Accepted"
+        case .some(false): return "Declined"
+        case .none: return "Pending"
+        }
+    }
+
+    private var canPersonalizeLabel: String {
+        (client.previewState?.canPersonalize ?? false) ? "Yes" : "No"
+    }
+
     // MARK: - Overrides Section
 
     private var overridesSection: some View {
         SectionCard(title: "Overrides", collapsible: true) {
-            if viewModel.hasOverrides {
+            if hasOverrides {
                 VStack(alignment: .leading, spacing: PreviewTheme.Spacing.md) {
-                    Text("\(viewModel.audienceOverrideCount) audience override\(viewModel.audienceOverrideCount == 1 ? "" : "s"), \(viewModel.variantOverrideCount) optimization override\(viewModel.variantOverrideCount == 1 ? "" : "s")")
+                    Text("\(audienceOverrides.count) audience override\(audienceOverrides.count == 1 ? "" : "s"), \(variantOverrides.count) optimization override\(variantOverrides.count == 1 ? "" : "s")")
                         .font(.system(size: PreviewTheme.FontSize.xs))
                         .foregroundColor(PreviewTheme.Colors.TextColor.secondary)
 
-                    if !viewModel.activeAudienceOverrides.isEmpty {
+                    if !audienceOverrides.isEmpty {
                         VStack(alignment: .leading, spacing: PreviewTheme.Spacing.xs) {
                             Text("Audience Overrides")
                                 .font(.system(size: PreviewTheme.FontSize.sm, weight: .semibold))
                                 .foregroundColor(PreviewTheme.Colors.TextColor.primary)
 
-                            ForEach(viewModel.activeAudienceOverrides, id: \.id) { override_ in
+                            ForEach(activeAudienceOverrides, id: \.id) { override_ in
                                 ListItemRow(
                                     label: override_.name,
                                     value: override_.state == .on ? "Activated" : "Deactivated",
@@ -692,19 +514,20 @@ struct PreviewPanelMain: View {
                                         label: "Reset",
                                         variant: .reset,
                                         handler: { viewModel.resetAudienceOverride(audienceId: override_.id) }
-                                    )
+                                    ),
+                                    actionAccessibilityID: "reset-audience-\(override_.id)"
                                 )
                             }
                         }
                     }
 
-                    if !viewModel.activeVariantOverrides.isEmpty {
+                    if !variantOverrides.isEmpty {
                         VStack(alignment: .leading, spacing: PreviewTheme.Spacing.xs) {
                             Text("Optimization Overrides")
                                 .font(.system(size: PreviewTheme.FontSize.sm, weight: .semibold))
                                 .foregroundColor(PreviewTheme.Colors.TextColor.primary)
 
-                            ForEach(viewModel.activeVariantOverrides, id: \.experienceId) { override_ in
+                            ForEach(activeVariantOverrides, id: \.experienceId) { override_ in
                                 ListItemRow(
                                     label: override_.name,
                                     value: override_.variantIndex == 0 ? "Baseline" : "Variant \(override_.variantIndex)",
@@ -712,7 +535,8 @@ struct PreviewPanelMain: View {
                                         label: "Reset",
                                         variant: .reset,
                                         handler: { viewModel.resetVariantOverride(experienceId: override_.experienceId) }
-                                    )
+                                    ),
+                                    actionAccessibilityID: "reset-variant-\(override_.experienceId)"
                                 )
                             }
                         }
@@ -745,8 +569,9 @@ struct PreviewPanelMain: View {
                     )
             }
             .padding(PreviewTheme.Spacing.lg)
-            .opacity(viewModel.hasOverrides ? 1.0 : PreviewTheme.Opacity.disabled)
-            .disabled(!viewModel.hasOverrides)
+            .opacity(hasOverrides ? 1.0 : PreviewTheme.Opacity.disabled)
+            .disabled(!hasOverrides)
+            .accessibilityIdentifier("reset-all-overrides")
         }
         .background(PreviewTheme.Colors.Background.primary)
         .alert("Reset to Actual State", isPresented: $showResetAlert) {
@@ -759,6 +584,23 @@ struct PreviewPanelMain: View {
         }
     }
 
+    // MARK: - Derived override summaries
+
+    private var activeAudienceOverrides: [(id: String, name: String, state: AudienceOverrideState)] {
+        audienceOverrides.map { audienceId, qualified in
+            let name = audienceNameMap[audienceId] ?? audienceId
+            let state: AudienceOverrideState = qualified ? .on : .off
+            return (id: audienceId, name: name, state: state)
+        }.sorted { $0.name < $1.name }
+    }
+
+    private var activeVariantOverrides: [(experienceId: String, name: String, variantIndex: Int)] {
+        variantOverrides.map { expId, variant in
+            let name = experienceNameMap[expId] ?? expId
+            return (experienceId: expId, name: name, variantIndex: variant)
+        }.sorted { $0.name < $1.name }
+    }
+
     // MARK: - Helpers
 
     private func stringValue(_ value: Any?) -> String {
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Resources/optimization-ios-bridge.umd.js b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Resources/optimization-ios-bridge.umd.js
index 9f452540..e008a84b 100644
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Resources/optimization-ios-bridge.umd.js
+++ b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Resources/optimization-ios-bridge.umd.js
@@ -1,3872 +1,2 @@
-!(function (e, t) {
-  'object' == typeof exports && 'object' == typeof module
-    ? (module.exports = t())
-    : 'function' == typeof define && define.amd
-      ? define([], t)
-      : 'object' == typeof exports
-        ? (exports.OptimizationBridge = t())
-        : (e.OptimizationBridge = t())
-})(globalThis, () =>
-  (() => {
-    'use strict'
-    let e, t, i, n, r, s, o
-    var a,
-      l = {}
-    ;((l.d = (e, t) => {
-      for (var i in t)
-        l.o(t, i) && !l.o(e, i) && Object.defineProperty(e, i, { enumerable: !0, get: t[i] })
-    }),
-      (l.o = (e, t) => Object.prototype.hasOwnProperty.call(e, t)))
-    var u = {}
-    l.d(u, { default: () => rg })
-    var c = Symbol.for('preact-signals')
-    function d() {
-      if (g > 1) g--
-      else {
-        for (var e, t = !1; void 0 !== y; ) {
-          var i = y
-          for (y = void 0, m++; void 0 !== i; ) {
-            var n = i.o
-            if (((i.o = void 0), (i.f &= -3), !(8 & i.f) && O(i)))
-              try {
-                i.c()
-              } catch (i) {
-                t || ((e = i), (t = !0))
-              }
-            i = n
-          }
-        }
-        if (((m = 0), g--, t)) throw e
-      }
-    }
-    function f(e) {
-      if (g > 0) return e()
-      g++
-      try {
-        return e()
-      } finally {
-        d()
-      }
-    }
-    var h = void 0
-    function p(e) {
-      var t = h
-      h = void 0
-      try {
-        return e()
-      } finally {
-        h = t
-      }
-    }
-    var v,
-      y = void 0,
-      g = 0,
-      m = 0,
-      b = 0
-    function w(e) {
-      if (void 0 !== h) {
-        var t = e.n
-        if (void 0 === t || t.t !== h)
-          return (
-            (t = { i: 0, S: e, p: h.s, n: void 0, t: h, e: void 0, x: void 0, r: t }),
-            void 0 !== h.s && (h.s.n = t),
-            (h.s = t),
-            (e.n = t),
-            32 & h.f && e.S(t),
-            t
-          )
-        if (-1 === t.i)
-          return (
-            (t.i = 0),
-            void 0 !== t.n &&
-              ((t.n.p = t.p),
-              void 0 !== t.p && (t.p.n = t.n),
-              (t.p = h.s),
-              (t.n = void 0),
-              (h.s.n = t),
-              (h.s = t)),
-            t
-          )
-      }
-    }
-    function _(e, t) {
-      ;((this.v = e),
-        (this.i = 0),
-        (this.n = void 0),
-        (this.t = void 0),
-        (this.W = null == t ? void 0 : t.watched),
-        (this.Z = null == t ? void 0 : t.unwatched),
-        (this.name = null == t ? void 0 : t.name))
-    }
-    function z(e, t) {
-      return new _(e, t)
-    }
-    function O(e) {
-      for (var t = e.s; void 0 !== t; t = t.n)
-        if (t.S.i !== t.i || !t.S.h() || t.S.i !== t.i) return !0
-      return !1
-    }
-    function E(e) {
-      for (var t = e.s; void 0 !== t; t = t.n) {
-        var i = t.S.n
-        if ((void 0 !== i && (t.r = i), (t.S.n = t), (t.i = -1), void 0 === t.n)) {
-          e.s = t
-          break
-        }
-      }
-    }
-    function k(e) {
-      for (var t = e.s, i = void 0; void 0 !== t; ) {
-        var n = t.p
-        ;(-1 === t.i
-          ? (t.S.U(t), void 0 !== n && (n.n = t.n), void 0 !== t.n && (t.n.p = n))
-          : (i = t),
-          (t.S.n = t.r),
-          void 0 !== t.r && (t.r = void 0),
-          (t = n))
-      }
-      e.s = i
-    }
-    function S(e, t) {
-      ;(_.call(this, void 0),
-        (this.x = e),
-        (this.s = void 0),
-        (this.g = b - 1),
-        (this.f = 4),
-        (this.W = null == t ? void 0 : t.watched),
-        (this.Z = null == t ? void 0 : t.unwatched),
-        (this.name = null == t ? void 0 : t.name))
-    }
-    function x(e, t) {
-      return new S(e, t)
-    }
-    function $(e) {
-      var t = e.u
-      if (((e.u = void 0), 'function' == typeof t)) {
-        g++
-        var i = h
-        h = void 0
-        try {
-          t()
-        } catch (t) {
-          throw ((e.f &= -2), (e.f |= 8), I(e), t)
-        } finally {
-          ;((h = i), d())
-        }
-      }
-    }
-    function I(e) {
-      for (var t = e.s; void 0 !== t; t = t.n) t.S.U(t)
-      ;((e.x = void 0), (e.s = void 0), $(e))
-    }
-    function P(e) {
-      if (h !== this) throw Error('Out-of-order effect')
-      ;(k(this), (h = e), (this.f &= -2), 8 & this.f && I(this), d())
-    }
-    function j(e, t) {
-      ;((this.x = e),
-        (this.u = void 0),
-        (this.s = void 0),
-        (this.o = void 0),
-        (this.f = 32),
-        (this.name = null == t ? void 0 : t.name),
-        v && v.push(this))
-    }
-    function T(e, t) {
-      var i = new j(e, t)
-      try {
-        i.c()
-      } catch (e) {
-        throw (i.d(), e)
-      }
-      var n = i.d.bind(i)
-      return ((n[Symbol.dispose] = n), n)
-    }
-    function F(e) {
-      return Object.getOwnPropertySymbols(e).filter((t) =>
-        Object.prototype.propertyIsEnumerable.call(e, t),
-      )
-    }
-    function A(e) {
-      return null == e
-        ? void 0 === e
-          ? '[object Undefined]'
-          : '[object Null]'
-        : Object.prototype.toString.call(e)
-    }
-    ;((_.prototype.brand = c),
-      (_.prototype.h = function () {
-        return !0
-      }),
-      (_.prototype.S = function (e) {
-        var t = this,
-          i = this.t
-        i !== e &&
-          void 0 === e.e &&
-          ((e.x = i),
-          (this.t = e),
-          void 0 !== i
-            ? (i.e = e)
-            : p(function () {
-                var e
-                null == (e = t.W) || e.call(t)
-              }))
-      }),
-      (_.prototype.U = function (e) {
-        var t = this
-        if (void 0 !== this.t) {
-          var i = e.e,
-            n = e.x
-          ;(void 0 !== i && ((i.x = n), (e.e = void 0)),
-            void 0 !== n && ((n.e = i), (e.x = void 0)),
-            e === this.t &&
-              ((this.t = n),
-              void 0 === n &&
-                p(function () {
-                  var e
-                  null == (e = t.Z) || e.call(t)
-                })))
-        }
-      }),
-      (_.prototype.subscribe = function (e) {
-        var t = this
-        return T(
-          function () {
-            var i = t.value,
-              n = h
-            h = void 0
-            try {
-              e(i)
-            } finally {
-              h = n
-            }
-          },
-          { name: 'sub' },
-        )
-      }),
-      (_.prototype.valueOf = function () {
-        return this.value
-      }),
-      (_.prototype.toString = function () {
-        return this.value + ''
-      }),
-      (_.prototype.toJSON = function () {
-        return this.value
-      }),
-      (_.prototype.peek = function () {
-        var e = h
-        h = void 0
-        try {
-          return this.value
-        } finally {
-          h = e
-        }
-      }),
-      Object.defineProperty(_.prototype, 'value', {
-        get: function () {
-          var e = w(this)
-          return (void 0 !== e && (e.i = this.i), this.v)
-        },
-        set: function (e) {
-          if (e !== this.v) {
-            if (m > 100) throw Error('Cycle detected')
-            ;((this.v = e), this.i++, b++, g++)
-            try {
-              for (var t = this.t; void 0 !== t; t = t.x) t.t.N()
-            } finally {
-              d()
-            }
-          }
-        },
-      }),
-      (S.prototype = new _()),
-      (S.prototype.h = function () {
-        if (((this.f &= -3), 1 & this.f)) return !1
-        if (32 == (36 & this.f) || ((this.f &= -5), this.g === b)) return !0
-        if (((this.g = b), (this.f |= 1), this.i > 0 && !O(this))) return ((this.f &= -2), !0)
-        var e = h
-        try {
-          ;(E(this), (h = this))
-          var t = this.x()
-          ;(16 & this.f || this.v !== t || 0 === this.i) &&
-            ((this.v = t), (this.f &= -17), this.i++)
-        } catch (e) {
-          ;((this.v = e), (this.f |= 16), this.i++)
-        }
-        return ((h = e), k(this), (this.f &= -2), !0)
-      }),
-      (S.prototype.S = function (e) {
-        if (void 0 === this.t) {
-          this.f |= 36
-          for (var t = this.s; void 0 !== t; t = t.n) t.S.S(t)
-        }
-        _.prototype.S.call(this, e)
-      }),
-      (S.prototype.U = function (e) {
-        if (void 0 !== this.t && (_.prototype.U.call(this, e), void 0 === this.t)) {
-          this.f &= -33
-          for (var t = this.s; void 0 !== t; t = t.n) t.S.U(t)
-        }
-      }),
-      (S.prototype.N = function () {
-        if (!(2 & this.f)) {
-          this.f |= 6
-          for (var e = this.t; void 0 !== e; e = e.x) e.t.N()
-        }
-      }),
-      Object.defineProperty(S.prototype, 'value', {
-        get: function () {
-          if (1 & this.f) throw Error('Cycle detected')
-          var e = w(this)
-          if ((this.h(), void 0 !== e && (e.i = this.i), 16 & this.f)) throw this.v
-          return this.v
-        },
-      }),
-      (j.prototype.c = function () {
-        var e = this.S()
-        try {
-          if (8 & this.f || void 0 === this.x) return
-          var t = this.x()
-          'function' == typeof t && (this.u = t)
-        } finally {
-          e()
-        }
-      }),
-      (j.prototype.S = function () {
-        if (1 & this.f) throw Error('Cycle detected')
-        ;((this.f |= 1), (this.f &= -9), $(this), E(this), g++)
-        var e = h
-        return ((h = this), P.bind(this, e))
-      }),
-      (j.prototype.N = function () {
-        2 & this.f || ((this.f |= 2), (this.o = y), (y = this))
-      }),
-      (j.prototype.d = function () {
-        ;((this.f |= 8), 1 & this.f || I(this))
-      }),
-      (j.prototype.dispose = function () {
-        this.d()
-      }))
-    let R = '[object RegExp]',
-      M = '[object String]',
-      C = '[object Number]',
-      B = '[object Boolean]',
-      q = '[object Arguments]',
-      U = '[object Symbol]',
-      N = '[object Date]',
-      V = '[object Map]',
-      D = '[object Set]',
-      Z = '[object Array]',
-      L = '[object ArrayBuffer]',
-      Q = '[object Object]',
-      J = '[object DataView]',
-      H = '[object Uint8Array]',
-      K = '[object Uint8ClampedArray]',
-      W = '[object Uint16Array]',
-      G = '[object Uint32Array]',
-      X = '[object Int8Array]',
-      Y = '[object Int16Array]',
-      ee = '[object Int32Array]',
-      et = '[object Float32Array]',
-      ei = '[object Float64Array]'
-    function en(e, t, i, n = new Map(), r) {
-      let s = r?.(e, t, i, n)
-      if (void 0 !== s) return s
-      if (null == e || ('object' != typeof e && 'function' != typeof e)) return e
-      if (n.has(e)) return n.get(e)
-      if (Array.isArray(e)) {
-        let t = Array(e.length)
-        n.set(e, t)
-        for (let s = 0; s < e.length; s++) t[s] = en(e[s], s, i, n, r)
-        return (
-          Object.hasOwn(e, 'index') && (t.index = e.index),
-          Object.hasOwn(e, 'input') && (t.input = e.input),
-          t
-        )
-      }
-      if (e instanceof Date) return new Date(e.getTime())
-      if (e instanceof RegExp) {
-        let t = new RegExp(e.source, e.flags)
-        return ((t.lastIndex = e.lastIndex), t)
-      }
-      if (e instanceof Map) {
-        let t = new Map()
-        for (let [s, o] of (n.set(e, t), e)) t.set(s, en(o, s, i, n, r))
-        return t
-      }
-      if (e instanceof Set) {
-        let t = new Set()
-        for (let s of (n.set(e, t), e)) t.add(en(s, void 0, i, n, r))
-        return t
-      }
-      if ('u' > typeof Buffer && Buffer.isBuffer(e)) return e.subarray()
-      if (ArrayBuffer.isView(e) && !(e instanceof DataView)) {
-        let t = new (Object.getPrototypeOf(e).constructor)(e.length)
-        n.set(e, t)
-        for (let s = 0; s < e.length; s++) t[s] = en(e[s], s, i, n, r)
-        return t
-      }
-      if (
-        e instanceof ArrayBuffer ||
-        ('u' > typeof SharedArrayBuffer && e instanceof SharedArrayBuffer)
-      )
-        return e.slice(0)
-      if (e instanceof DataView) {
-        let t = new DataView(e.buffer.slice(0), e.byteOffset, e.byteLength)
-        return (n.set(e, t), er(t, e, i, n, r), t)
-      }
-      if ('u' > typeof File && e instanceof File) {
-        let t = new File([e], e.name, { type: e.type })
-        return (n.set(e, t), er(t, e, i, n, r), t)
-      }
-      if ('u' > typeof Blob && e instanceof Blob) {
-        let t = new Blob([e], { type: e.type })
-        return (n.set(e, t), er(t, e, i, n, r), t)
-      }
-      if (e instanceof Error) {
-        let t = new e.constructor()
-        return (
-          n.set(e, t),
-          (t.message = e.message),
-          (t.name = e.name),
-          (t.stack = e.stack),
-          (t.cause = e.cause),
-          er(t, e, i, n, r),
-          t
-        )
-      }
-      if (e instanceof Boolean) {
-        let t = new Boolean(e.valueOf())
-        return (n.set(e, t), er(t, e, i, n, r), t)
-      }
-      if (e instanceof Number) {
-        let t = new Number(e.valueOf())
-        return (n.set(e, t), er(t, e, i, n, r), t)
-      }
-      if (e instanceof String) {
-        let t = new String(e.valueOf())
-        return (n.set(e, t), er(t, e, i, n, r), t)
-      }
-      if (
-        'object' == typeof e &&
-        (function (e) {
-          switch (A(e)) {
-            case q:
-            case Z:
-            case L:
-            case J:
-            case B:
-            case N:
-            case et:
-            case ei:
-            case X:
-            case Y:
-            case ee:
-            case V:
-            case C:
-            case Q:
-            case R:
-            case D:
-            case M:
-            case U:
-            case H:
-            case K:
-            case W:
-            case G:
-              return !0
-            default:
-              return !1
-          }
-        })(e)
-      ) {
-        let t = Object.create(Object.getPrototypeOf(e))
-        return (n.set(e, t), er(t, e, i, n, r), t)
-      }
-      return e
-    }
-    function er(e, t, i = e, n, r) {
-      let s = [...Object.keys(t), ...F(t)]
-      for (let o = 0; o < s.length; o++) {
-        let a = s[o],
-          l = Object.getOwnPropertyDescriptor(e, a)
-        ;(null == l || l.writable) && (e[a] = en(t[a], a, i, n, r))
-      }
-    }
-    function es(e) {
-      return en(e, void 0, e, new Map(), void 0)
-    }
-    function eo(e) {
-      return {
-        get current() {
-          return es(e.value)
-        },
-        subscribe: (t) => ({
-          unsubscribe: T(() => {
-            t(es(e.value))
-          }),
-        }),
-        subscribeOnce(t) {
-          let i = !1,
-            n = !1,
-            r = () => void 0
-          return (
-            (r = T(() => {
-              if (i) return
-              let { value: s } = e
-              if (null == s) return
-              i = !0
-              let o = null
-              try {
-                t(es(s))
-              } catch (e) {
-                o = e instanceof Error ? e : Error(`Subscriber threw non-Error value: ${String(e)}`)
-              }
-              if ((n ? r() : queueMicrotask(r), o)) throw o
-            })),
-            (n = !0),
-            {
-              unsubscribe: () => {
-                !i && ((i = !0), n && r())
-              },
-            }
-          )
-        },
-      }
-    }
-    let ea = z(),
-      el = z(),
-      eu = z(),
-      ec = z(),
-      ed = z(!0),
-      ef = z(!1),
-      eh = z(!1),
-      ep = z(),
-      ev = x(() => void 0 !== ep.value),
-      ey = z(),
-      eg = {
-        blockedEvent: el,
-        changes: ea,
-        consent: eu,
-        event: ec,
-        online: ed,
-        previewPanelAttached: ef,
-        previewPanelOpen: eh,
-        selectedOptimizations: ep,
-        canOptimize: ev,
-        profile: ey,
-      },
-      em = { batch: f, computed: x, effect: T, untracked: p }
-    function eb(e, t, i) {
-      function n(i, n) {
-        if (
-          (i._zod ||
-            Object.defineProperty(i, '_zod', {
-              value: { def: n, constr: o, traits: new Set() },
-              enumerable: !1,
-            }),
-          i._zod.traits.has(e))
-        )
-          return
-        ;(i._zod.traits.add(e), t(i, n))
-        let r = o.prototype,
-          s = Object.keys(r)
-        for (let e = 0; e < s.length; e++) {
-          let t = s[e]
-          t in i || (i[t] = r[t].bind(i))
-        }
-      }
-      let r = i?.Parent ?? Object
-      class s extends r {}
-      function o(e) {
-        var t
-        let r = i?.Parent ? new s() : this
-        for (let i of (n(r, e), (t = r._zod).deferred ?? (t.deferred = []), r._zod.deferred)) i()
-        return r
-      }
-      return (
-        Object.defineProperty(s, 'name', { value: e }),
-        Object.defineProperty(o, 'init', { value: n }),
-        Object.defineProperty(o, Symbol.hasInstance, {
-          value: (t) => (!!i?.Parent && t instanceof i.Parent) || t?._zod?.traits?.has(e),
-        }),
-        Object.defineProperty(o, 'name', { value: e }),
-        o
-      )
-    }
-    ;(Object.freeze({ status: 'aborted' }), Symbol('zod_brand'))
-    class ew extends Error {
-      constructor() {
-        super('Encountered Promise during synchronous parse. Use .parseAsync() instead.')
-      }
-    }
-    let e_ = {}
-    function ez(e) {
-      return (e && Object.assign(e_, e), e_)
-    }
-    function eO(e, t = '|') {
-      return e.map((e) => eB(e)).join(t)
-    }
-    function eE(e, t) {
-      return 'bigint' == typeof t ? t.toString() : t
-    }
-    function ek(e) {
-      return {
-        get value() {
-          {
-            let t = e()
-            return (Object.defineProperty(this, 'value', { value: t }), t)
-          }
-        },
-      }
-    }
-    function eS(e) {
-      let t = +!!e.startsWith('^'),
-        i = e.endsWith('$') ? e.length - 1 : e.length
-      return e.slice(t, i)
-    }
-    let ex = Symbol('evaluating')
-    function e$(e, t, i) {
-      let n
-      Object.defineProperty(e, t, {
-        get() {
-          if (n !== ex) return (void 0 === n && ((n = ex), (n = i())), n)
-        },
-        set(i) {
-          Object.defineProperty(e, t, { value: i })
-        },
-        configurable: !0,
-      })
-    }
-    function eI(e, t, i) {
-      Object.defineProperty(e, t, { value: i, writable: !0, enumerable: !0, configurable: !0 })
-    }
-    function eP(...e) {
-      let t = {}
-      for (let i of e) Object.assign(t, Object.getOwnPropertyDescriptors(i))
-      return Object.defineProperties({}, t)
-    }
-    let ej = 'captureStackTrace' in Error ? Error.captureStackTrace : (...e) => {}
-    function eT(e) {
-      return 'object' == typeof e && null !== e && !Array.isArray(e)
-    }
-    function eF(e) {
-      if (!1 === eT(e)) return !1
-      let t = e.constructor
-      if (void 0 === t || 'function' != typeof t) return !0
-      let i = t.prototype
-      return !1 !== eT(i) && !1 !== Object.prototype.hasOwnProperty.call(i, 'isPrototypeOf')
-    }
-    ek(() => {
-      if ('u' > typeof navigator && navigator?.userAgent?.includes('Cloudflare')) return !1
-      try {
-        return (Function(''), !0)
-      } catch (e) {
-        return !1
-      }
-    })
-    let eA = new Set(['string', 'number', 'symbol'])
-    function eR(e) {
-      return e.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-    }
-    function eM(e, t, i) {
-      let n = new e._zod.constr(t ?? e._zod.def)
-      return ((!t || i?.parent) && (n._zod.parent = e), n)
-    }
-    function eC(e) {
-      if (!e) return {}
-      if ('string' == typeof e) return { error: () => e }
-      if (e?.message !== void 0) {
-        if (e?.error !== void 0) throw Error('Cannot specify both `message` and `error` params')
-        e.error = e.message
-      }
-      return (delete e.message, 'string' == typeof e.error) ? { ...e, error: () => e.error } : e
-    }
-    function eB(e) {
-      return 'bigint' == typeof e ? e.toString() + 'n' : 'string' == typeof e ? `"${e}"` : `${e}`
-    }
-    function eq(e, t = 0) {
-      if (!0 === e.aborted) return !0
-      for (let i = t; i < e.issues.length; i++) if (e.issues[i]?.continue !== !0) return !0
-      return !1
-    }
-    function eU(e, t) {
-      return t.map((t) => (t.path ?? (t.path = []), t.path.unshift(e), t))
-    }
-    function eN(e) {
-      return 'string' == typeof e ? e : e?.message
-    }
-    function eV(e, t, i) {
-      let n = { ...e, path: e.path ?? [] }
-      return (
-        e.message ||
-          (n.message =
-            eN(e.inst?._zod.def?.error?.(e)) ??
-            eN(t?.error?.(e)) ??
-            eN(i.customError?.(e)) ??
-            eN(i.localeError?.(e)) ??
-            'Invalid input'),
-        delete n.inst,
-        delete n.continue,
-        t?.reportInput || delete n.input,
-        n
-      )
-    }
-    function eD(e) {
-      return Array.isArray(e) ? 'array' : 'string' == typeof e ? 'string' : 'unknown'
-    }
-    let eZ = (e, t) => {
-        ;((e.name = '$ZodError'),
-          Object.defineProperty(e, '_zod', { value: e._zod, enumerable: !1 }),
-          Object.defineProperty(e, 'issues', { value: t, enumerable: !1 }),
-          (e.message = JSON.stringify(t, eE, 2)),
-          Object.defineProperty(e, 'toString', { value: () => e.message, enumerable: !1 }))
-      },
-      eL = eb('$ZodError', eZ),
-      eQ = eb('$ZodError', eZ, { Parent: Error }),
-      eJ =
-        ((e = eQ),
-        (t, i, n, r) => {
-          let s = n ? Object.assign(n, { async: !1 }) : { async: !1 },
-            o = t._zod.run({ value: i, issues: [] }, s)
-          if (o instanceof Promise) throw new ew()
-          if (o.issues.length) {
-            let t = new (r?.Err ?? e)(o.issues.map((e) => eV(e, s, ez())))
-            throw (ej(t, r?.callee), t)
-          }
-          return o.value
-        }),
-      eH =
-        ((t = eQ),
-        async (e, i, n, r) => {
-          let s = n ? Object.assign(n, { async: !0 }) : { async: !0 },
-            o = e._zod.run({ value: i, issues: [] }, s)
-          if ((o instanceof Promise && (o = await o), o.issues.length)) {
-            let e = new (r?.Err ?? t)(o.issues.map((e) => eV(e, s, ez())))
-            throw (ej(e, r?.callee), e)
-          }
-          return o.value
-        }),
-      eK =
-        ((i = eQ),
-        (e, t, n) => {
-          let r = n ? { ...n, async: !1 } : { async: !1 },
-            s = e._zod.run({ value: t, issues: [] }, r)
-          if (s instanceof Promise) throw new ew()
-          return s.issues.length
-            ? { success: !1, error: new (i ?? eL)(s.issues.map((e) => eV(e, r, ez()))) }
-            : { success: !0, data: s.value }
-        }),
-      eW =
-        ((n = eQ),
-        async (e, t, i) => {
-          let r = i ? Object.assign(i, { async: !0 }) : { async: !0 },
-            s = e._zod.run({ value: t, issues: [] }, r)
-          return (
-            s instanceof Promise && (s = await s),
-            s.issues.length
-              ? { success: !1, error: new n(s.issues.map((e) => eV(e, r, ez()))) }
-              : { success: !0, data: s.value }
-          )
-        }),
-      eG =
-        /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/,
-      eX =
-        '(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))',
-      eY = RegExp(`^${eX}$`)
-    function e0(e) {
-      let t = '(?:[01]\\d|2[0-3]):[0-5]\\d'
-      return 'number' == typeof e.precision
-        ? -1 === e.precision
-          ? `${t}`
-          : 0 === e.precision
-            ? `${t}:[0-5]\\d`
-            : `${t}:[0-5]\\d\\.\\d{${e.precision}}`
-        : `${t}(?::[0-5]\\d(?:\\.\\d+)?)?`
-    }
-    let e1 = /^-?\d+(?:\.\d+)?$/,
-      e2 = /^(?:true|false)$/i,
-      e6 = /^null$/i,
-      e3 = eb('$ZodCheck', (e, t) => {
-        var i
-        ;(e._zod ?? (e._zod = {}), (e._zod.def = t), (i = e._zod).onattach ?? (i.onattach = []))
-      }),
-      e4 = eb('$ZodCheckMinLength', (e, t) => {
-        var i
-        ;(e3.init(e, t),
-          (i = e._zod.def).when ??
-            (i.when = (e) => {
-              let t = e.value
-              return null != t && void 0 !== t.length
-            }),
-          e._zod.onattach.push((e) => {
-            let i = e._zod.bag.minimum ?? -1 / 0
-            t.minimum > i && (e._zod.bag.minimum = t.minimum)
-          }),
-          (e._zod.check = (i) => {
-            let n = i.value
-            if (n.length >= t.minimum) return
-            let r = eD(n)
-            i.issues.push({
-              origin: r,
-              code: 'too_small',
-              minimum: t.minimum,
-              inclusive: !0,
-              input: n,
-              inst: e,
-              continue: !t.abort,
-            })
-          }))
-      }),
-      e8 = eb('$ZodCheckLengthEquals', (e, t) => {
-        var i
-        ;(e3.init(e, t),
-          (i = e._zod.def).when ??
-            (i.when = (e) => {
-              let t = e.value
-              return null != t && void 0 !== t.length
-            }),
-          e._zod.onattach.push((e) => {
-            let i = e._zod.bag
-            ;((i.minimum = t.length), (i.maximum = t.length), (i.length = t.length))
-          }),
-          (e._zod.check = (i) => {
-            let n = i.value,
-              r = n.length
-            if (r === t.length) return
-            let s = eD(n),
-              o = r > t.length
-            i.issues.push({
-              origin: s,
-              ...(o
-                ? { code: 'too_big', maximum: t.length }
-                : { code: 'too_small', minimum: t.length }),
-              inclusive: !0,
-              exact: !0,
-              input: i.value,
-              inst: e,
-              continue: !t.abort,
-            })
-          }))
-      }),
-      e5 = eb('$ZodCheckStringFormat', (e, t) => {
-        var i, n
-        ;(e3.init(e, t),
-          e._zod.onattach.push((e) => {
-            let i = e._zod.bag
-            ;((i.format = t.format),
-              t.pattern && (i.patterns ?? (i.patterns = new Set()), i.patterns.add(t.pattern)))
-          }),
-          t.pattern
-            ? ((i = e._zod).check ??
-              (i.check = (i) => {
-                ;((t.pattern.lastIndex = 0),
-                  t.pattern.test(i.value) ||
-                    i.issues.push({
-                      origin: 'string',
-                      code: 'invalid_format',
-                      format: t.format,
-                      input: i.value,
-                      ...(t.pattern ? { pattern: t.pattern.toString() } : {}),
-                      inst: e,
-                      continue: !t.abort,
-                    }))
-              }))
-            : ((n = e._zod).check ?? (n.check = () => {})))
-      }),
-      e9 = { major: 4, minor: 3, patch: 6 },
-      e7 = eb('$ZodType', (e, t) => {
-        var i
-        ;(e ?? (e = {}), (e._zod.def = t), (e._zod.bag = e._zod.bag || {}), (e._zod.version = e9))
-        let n = [...(e._zod.def.checks ?? [])]
-        for (let t of (e._zod.traits.has('$ZodCheck') && n.unshift(e), n))
-          for (let i of t._zod.onattach) i(e)
-        if (0 === n.length)
-          ((i = e._zod).deferred ?? (i.deferred = []),
-            e._zod.deferred?.push(() => {
-              e._zod.run = e._zod.parse
-            }))
-        else {
-          let t = (e, t, i) => {
-              let n,
-                r = eq(e)
-              for (let s of t) {
-                if (s._zod.def.when) {
-                  if (!s._zod.def.when(e)) continue
-                } else if (r) continue
-                let t = e.issues.length,
-                  o = s._zod.check(e)
-                if (o instanceof Promise && i?.async === !1) throw new ew()
-                if (n || o instanceof Promise)
-                  n = (n ?? Promise.resolve()).then(async () => {
-                    ;(await o, e.issues.length !== t && (r || (r = eq(e, t))))
-                  })
-                else {
-                  if (e.issues.length === t) continue
-                  r || (r = eq(e, t))
-                }
-              }
-              return n ? n.then(() => e) : e
-            },
-            i = (i, r, s) => {
-              if (eq(i)) return ((i.aborted = !0), i)
-              let o = t(r, n, s)
-              if (o instanceof Promise) {
-                if (!1 === s.async) throw new ew()
-                return o.then((t) => e._zod.parse(t, s))
-              }
-              return e._zod.parse(o, s)
-            }
-          e._zod.run = (r, s) => {
-            if (s.skipChecks) return e._zod.parse(r, s)
-            if ('backward' === s.direction) {
-              let t = e._zod.parse({ value: r.value, issues: [] }, { ...s, skipChecks: !0 })
-              return t instanceof Promise ? t.then((e) => i(e, r, s)) : i(t, r, s)
-            }
-            let o = e._zod.parse(r, s)
-            if (o instanceof Promise) {
-              if (!1 === s.async) throw new ew()
-              return o.then((e) => t(e, n, s))
-            }
-            return t(o, n, s)
-          }
-        }
-        e$(e, '~standard', () => ({
-          validate: (t) => {
-            try {
-              let i = eK(e, t)
-              return i.success ? { value: i.data } : { issues: i.error?.issues }
-            } catch (i) {
-              return eW(e, t).then((e) =>
-                e.success ? { value: e.data } : { issues: e.error?.issues },
-              )
-            }
-          },
-          vendor: 'zod',
-          version: 1,
-        }))
-      }),
-      te = eb('$ZodString', (e, t) => {
-        var i
-        let n
-        ;(e7.init(e, t),
-          (e._zod.pattern =
-            [...(e?._zod.bag?.patterns ?? [])].pop() ??
-            ((n = (i = e._zod.bag)
-              ? `[\\s\\S]{${i?.minimum ?? 0},${i?.maximum ?? ''}}`
-              : '[\\s\\S]*'),
-            RegExp(`^${n}$`))),
-          (e._zod.parse = (i, n) => {
-            if (t.coerce)
-              try {
-                i.value = String(i.value)
-              } catch (e) {}
-            return (
-              'string' == typeof i.value ||
-                i.issues.push({
-                  expected: 'string',
-                  code: 'invalid_type',
-                  input: i.value,
-                  inst: e,
-                }),
-              i
-            )
-          }))
-      }),
-      tt = eb('$ZodStringFormat', (e, t) => {
-        ;(e5.init(e, t), te.init(e, t))
-      }),
-      ti = eb('$ZodISODateTime', (e, t) => {
-        let i, n, r
-        ;(t.pattern ??
-          ((i = e0({ precision: t.precision })),
-          (n = ['Z']),
-          t.local && n.push(''),
-          t.offset && n.push('([+-](?:[01]\\d|2[0-3]):[0-5]\\d)'),
-          (r = `${i}(?:${n.join('|')})`),
-          (t.pattern = RegExp(`^${eX}T(?:${r})$`))),
-          tt.init(e, t))
-      }),
-      tn =
-        ((e, t) => {
-          ;(t.pattern ?? (t.pattern = eY), tt.init(e, t))
-        },
-        eb('$ZodNumber', (e, t) => {
-          ;(e7.init(e, t),
-            (e._zod.pattern = e._zod.bag.pattern ?? e1),
-            (e._zod.parse = (i, n) => {
-              if (t.coerce)
-                try {
-                  i.value = Number(i.value)
-                } catch (e) {}
-              let r = i.value
-              if ('number' == typeof r && !Number.isNaN(r) && Number.isFinite(r)) return i
-              let s =
-                'number' == typeof r
-                  ? Number.isNaN(r)
-                    ? 'NaN'
-                    : Number.isFinite(r)
-                      ? void 0
-                      : 'Infinity'
-                  : void 0
-              return (
-                i.issues.push({
-                  expected: 'number',
-                  code: 'invalid_type',
-                  input: r,
-                  inst: e,
-                  ...(s ? { received: s } : {}),
-                }),
-                i
-              )
-            }))
-        })),
-      tr = eb('$ZodBoolean', (e, t) => {
-        ;(e7.init(e, t),
-          (e._zod.pattern = e2),
-          (e._zod.parse = (i, n) => {
-            if (t.coerce)
-              try {
-                i.value = !!i.value
-              } catch (e) {}
-            let r = i.value
-            return (
-              'boolean' == typeof r ||
-                i.issues.push({ expected: 'boolean', code: 'invalid_type', input: r, inst: e }),
-              i
-            )
-          }))
-      }),
-      ts = eb('$ZodNull', (e, t) => {
-        ;(e7.init(e, t),
-          (e._zod.pattern = e6),
-          (e._zod.values = new Set([null])),
-          (e._zod.parse = (t, i) => {
-            let n = t.value
-            return (
-              null === n ||
-                t.issues.push({ expected: 'null', code: 'invalid_type', input: n, inst: e }),
-              t
-            )
-          }))
-      }),
-      to = eb('$ZodAny', (e, t) => {
-        ;(e7.init(e, t), (e._zod.parse = (e) => e))
-      }),
-      ta = eb('$ZodUnknown', (e, t) => {
-        ;(e7.init(e, t), (e._zod.parse = (e) => e))
-      })
-    function tl(e, t, i) {
-      ;(e.issues.length && t.issues.push(...eU(i, e.issues)), (t.value[i] = e.value))
-    }
-    let tu = eb('$ZodArray', (e, t) => {
-      ;(e7.init(e, t),
-        (e._zod.parse = (i, n) => {
-          let r = i.value
-          if (!Array.isArray(r))
-            return (
-              i.issues.push({ expected: 'array', code: 'invalid_type', input: r, inst: e }),
-              i
-            )
-          i.value = Array(r.length)
-          let s = []
-          for (let e = 0; e < r.length; e++) {
-            let o = r[e],
-              a = t.element._zod.run({ value: o, issues: [] }, n)
-            a instanceof Promise ? s.push(a.then((t) => tl(t, i, e))) : tl(a, i, e)
-          }
-          return s.length ? Promise.all(s).then(() => i) : i
-        }))
-    })
-    function tc(e, t, i, n, r) {
-      if (e.issues.length) {
-        if (r && !(i in n)) return
-        t.issues.push(...eU(i, e.issues))
-      }
-      void 0 === e.value ? i in n && (t.value[i] = void 0) : (t.value[i] = e.value)
-    }
-    let td = eb('$ZodObject', (e, t) => {
-      let i
-      e7.init(e, t)
-      let n = Object.getOwnPropertyDescriptor(t, 'shape')
-      if (!n?.get) {
-        let e = t.shape
-        Object.defineProperty(t, 'shape', {
-          get: () => {
-            let i = { ...e }
-            return (Object.defineProperty(t, 'shape', { value: i }), i)
-          },
-        })
-      }
-      let r = ek(() =>
-        (function (e) {
-          var t
-          let i = Object.keys(e.shape)
-          for (let t of i)
-            if (!e.shape?.[t]?._zod?.traits?.has('$ZodType'))
-              throw Error(`Invalid element at key "${t}": expected a Zod schema`)
-          let n = Object.keys((t = e.shape)).filter(
-            (e) => 'optional' === t[e]._zod.optin && 'optional' === t[e]._zod.optout,
-          )
-          return { ...e, keys: i, keySet: new Set(i), numKeys: i.length, optionalKeys: new Set(n) }
-        })(t),
-      )
-      e$(e._zod, 'propValues', () => {
-        let e = t.shape,
-          i = {}
-        for (let t in e) {
-          let n = e[t]._zod
-          if (n.values) for (let e of (i[t] ?? (i[t] = new Set()), n.values)) i[t].add(e)
-        }
-        return i
-      })
-      let s = t.catchall
-      e._zod.parse = (t, n) => {
-        i ?? (i = r.value)
-        let o = t.value
-        if (!eT(o))
-          return (t.issues.push({ expected: 'object', code: 'invalid_type', input: o, inst: e }), t)
-        t.value = {}
-        let a = [],
-          l = i.shape
-        for (let e of i.keys) {
-          let i = l[e],
-            r = 'optional' === i._zod.optout,
-            s = i._zod.run({ value: o[e], issues: [] }, n)
-          s instanceof Promise ? a.push(s.then((i) => tc(i, t, e, o, r))) : tc(s, t, e, o, r)
-        }
-        return s
-          ? (function (e, t, i, n, r, s) {
-              let o = [],
-                a = r.keySet,
-                l = r.catchall._zod,
-                u = l.def.type,
-                c = 'optional' === l.optout
-              for (let r in t) {
-                if (a.has(r)) continue
-                if ('never' === u) {
-                  o.push(r)
-                  continue
-                }
-                let s = l.run({ value: t[r], issues: [] }, n)
-                s instanceof Promise ? e.push(s.then((e) => tc(e, i, r, t, c))) : tc(s, i, r, t, c)
-              }
-              return (o.length &&
-                i.issues.push({ code: 'unrecognized_keys', keys: o, input: t, inst: s }),
-              e.length)
-                ? Promise.all(e).then(() => i)
-                : i
-            })(a, o, t, n, r.value, e)
-          : a.length
-            ? Promise.all(a).then(() => t)
-            : t
-      }
-    })
-    function tf(e, t, i, n) {
-      for (let i of e) if (0 === i.issues.length) return ((t.value = i.value), t)
-      let r = e.filter((e) => !eq(e))
-      return 1 === r.length
-        ? ((t.value = r[0].value), r[0])
-        : (t.issues.push({
-            code: 'invalid_union',
-            input: t.value,
-            inst: i,
-            errors: e.map((e) => e.issues.map((e) => eV(e, n, ez()))),
-          }),
-          t)
-    }
-    let th = eb('$ZodUnion', (e, t) => {
-        ;(e7.init(e, t),
-          e$(e._zod, 'optin', () =>
-            t.options.some((e) => 'optional' === e._zod.optin) ? 'optional' : void 0,
-          ),
-          e$(e._zod, 'optout', () =>
-            t.options.some((e) => 'optional' === e._zod.optout) ? 'optional' : void 0,
-          ),
-          e$(e._zod, 'values', () => {
-            if (t.options.every((e) => e._zod.values))
-              return new Set(t.options.flatMap((e) => Array.from(e._zod.values)))
-          }),
-          e$(e._zod, 'pattern', () => {
-            if (t.options.every((e) => e._zod.pattern)) {
-              let e = t.options.map((e) => e._zod.pattern)
-              return RegExp(`^(${e.map((e) => eS(e.source)).join('|')})$`)
-            }
-          }))
-        let i = 1 === t.options.length,
-          n = t.options[0]._zod.run
-        e._zod.parse = (r, s) => {
-          if (i) return n(r, s)
-          let o = !1,
-            a = []
-          for (let e of t.options) {
-            let t = e._zod.run({ value: r.value, issues: [] }, s)
-            if (t instanceof Promise) (a.push(t), (o = !0))
-            else {
-              if (0 === t.issues.length) return t
-              a.push(t)
-            }
-          }
-          return o ? Promise.all(a).then((t) => tf(t, r, e, s)) : tf(a, r, e, s)
-        }
-      }),
-      tp = eb('$ZodDiscriminatedUnion', (e, t) => {
-        ;((t.inclusive = !1), th.init(e, t))
-        let i = e._zod.parse
-        e$(e._zod, 'propValues', () => {
-          let e = {}
-          for (let i of t.options) {
-            let n = i._zod.propValues
-            if (!n || 0 === Object.keys(n).length)
-              throw Error(`Invalid discriminated union option at index "${t.options.indexOf(i)}"`)
-            for (let [t, i] of Object.entries(n))
-              for (let n of (e[t] || (e[t] = new Set()), i)) e[t].add(n)
-          }
-          return e
-        })
-        let n = ek(() => {
-          let e = t.options,
-            i = new Map()
-          for (let n of e) {
-            let e = n._zod.propValues?.[t.discriminator]
-            if (!e || 0 === e.size)
-              throw Error(`Invalid discriminated union option at index "${t.options.indexOf(n)}"`)
-            for (let t of e) {
-              if (i.has(t)) throw Error(`Duplicate discriminator value "${String(t)}"`)
-              i.set(t, n)
-            }
-          }
-          return i
-        })
-        e._zod.parse = (r, s) => {
-          let o = r.value
-          if (!eT(o))
-            return (
-              r.issues.push({ code: 'invalid_type', expected: 'object', input: o, inst: e }),
-              r
-            )
-          let a = n.value.get(o?.[t.discriminator])
-          return a
-            ? a._zod.run(r, s)
-            : t.unionFallback
-              ? i(r, s)
-              : (r.issues.push({
-                  code: 'invalid_union',
-                  errors: [],
-                  note: 'No matching discriminator',
-                  discriminator: t.discriminator,
-                  input: o,
-                  path: [t.discriminator],
-                  inst: e,
-                }),
-                r)
-        }
-      }),
-      tv = eb('$ZodRecord', (e, t) => {
-        ;(e7.init(e, t),
-          (e._zod.parse = (i, n) => {
-            let r = i.value
-            if (!eF(r))
-              return (
-                i.issues.push({ expected: 'record', code: 'invalid_type', input: r, inst: e }),
-                i
-              )
-            let s = [],
-              o = t.keyType._zod.values
-            if (o) {
-              let a
-              i.value = {}
-              let l = new Set()
-              for (let e of o)
-                if ('string' == typeof e || 'number' == typeof e || 'symbol' == typeof e) {
-                  l.add('number' == typeof e ? e.toString() : e)
-                  let o = t.valueType._zod.run({ value: r[e], issues: [] }, n)
-                  o instanceof Promise
-                    ? s.push(
-                        o.then((t) => {
-                          ;(t.issues.length && i.issues.push(...eU(e, t.issues)),
-                            (i.value[e] = t.value))
-                        }),
-                      )
-                    : (o.issues.length && i.issues.push(...eU(e, o.issues)), (i.value[e] = o.value))
-                }
-              for (let e in r) l.has(e) || (a = a ?? []).push(e)
-              a &&
-                a.length > 0 &&
-                i.issues.push({ code: 'unrecognized_keys', input: r, inst: e, keys: a })
-            } else
-              for (let o of ((i.value = {}), Reflect.ownKeys(r))) {
-                if ('__proto__' === o) continue
-                let a = t.keyType._zod.run({ value: o, issues: [] }, n)
-                if (a instanceof Promise)
-                  throw Error('Async schemas not supported in object keys currently')
-                if ('string' == typeof o && e1.test(o) && a.issues.length) {
-                  let e = t.keyType._zod.run({ value: Number(o), issues: [] }, n)
-                  if (e instanceof Promise)
-                    throw Error('Async schemas not supported in object keys currently')
-                  0 === e.issues.length && (a = e)
-                }
-                if (a.issues.length) {
-                  'loose' === t.mode
-                    ? (i.value[o] = r[o])
-                    : i.issues.push({
-                        code: 'invalid_key',
-                        origin: 'record',
-                        issues: a.issues.map((e) => eV(e, n, ez())),
-                        input: o,
-                        path: [o],
-                        inst: e,
-                      })
-                  continue
-                }
-                let l = t.valueType._zod.run({ value: r[o], issues: [] }, n)
-                l instanceof Promise
-                  ? s.push(
-                      l.then((e) => {
-                        ;(e.issues.length && i.issues.push(...eU(o, e.issues)),
-                          (i.value[a.value] = e.value))
-                      }),
-                    )
-                  : (l.issues.length && i.issues.push(...eU(o, l.issues)),
-                    (i.value[a.value] = l.value))
-              }
-            return s.length ? Promise.all(s).then(() => i) : i
-          }))
-      }),
-      ty = eb('$ZodEnum', (e, t) => {
-        var i
-        let n
-        e7.init(e, t)
-        let r =
-            ((n = Object.values((i = t.entries)).filter((e) => 'number' == typeof e)),
-            Object.entries(i)
-              .filter(([e, t]) => -1 === n.indexOf(+e))
-              .map(([e, t]) => t)),
-          s = new Set(r)
-        ;((e._zod.values = s),
-          (e._zod.pattern = RegExp(
-            `^(${r
-              .filter((e) => eA.has(typeof e))
-              .map((e) => ('string' == typeof e ? eR(e) : e.toString()))
-              .join('|')})$`,
-          )),
-          (e._zod.parse = (t, i) => {
-            let n = t.value
-            return (
-              s.has(n) || t.issues.push({ code: 'invalid_value', values: r, input: n, inst: e }),
-              t
-            )
-          }))
-      }),
-      tg = eb('$ZodLiteral', (e, t) => {
-        if ((e7.init(e, t), 0 === t.values.length))
-          throw Error('Cannot create literal schema with no valid values')
-        let i = new Set(t.values)
-        ;((e._zod.values = i),
-          (e._zod.pattern = RegExp(
-            `^(${t.values.map((e) => ('string' == typeof e ? eR(e) : e ? eR(e.toString()) : String(e))).join('|')})$`,
-          )),
-          (e._zod.parse = (n, r) => {
-            let s = n.value
-            return (
-              i.has(s) ||
-                n.issues.push({ code: 'invalid_value', values: t.values, input: s, inst: e }),
-              n
-            )
-          }))
-      })
-    function tm(e, t) {
-      return e.issues.length && void 0 === t ? { issues: [], value: void 0 } : e
-    }
-    let tb = eb('$ZodOptional', (e, t) => {
-        ;(e7.init(e, t),
-          (e._zod.optin = 'optional'),
-          (e._zod.optout = 'optional'),
-          e$(e._zod, 'values', () =>
-            t.innerType._zod.values ? new Set([...t.innerType._zod.values, void 0]) : void 0,
-          ),
-          e$(e._zod, 'pattern', () => {
-            let e = t.innerType._zod.pattern
-            return e ? RegExp(`^(${eS(e.source)})?$`) : void 0
-          }),
-          (e._zod.parse = (e, i) => {
-            if ('optional' === t.innerType._zod.optin) {
-              let n = t.innerType._zod.run(e, i)
-              return n instanceof Promise ? n.then((t) => tm(t, e.value)) : tm(n, e.value)
-            }
-            return void 0 === e.value ? e : t.innerType._zod.run(e, i)
-          }))
-      }),
-      tw = eb('$ZodNullable', (e, t) => {
-        ;(e7.init(e, t),
-          e$(e._zod, 'optin', () => t.innerType._zod.optin),
-          e$(e._zod, 'optout', () => t.innerType._zod.optout),
-          e$(e._zod, 'pattern', () => {
-            let e = t.innerType._zod.pattern
-            return e ? RegExp(`^(${eS(e.source)}|null)$`) : void 0
-          }),
-          e$(e._zod, 'values', () =>
-            t.innerType._zod.values ? new Set([...t.innerType._zod.values, null]) : void 0,
-          ),
-          (e._zod.parse = (e, i) => (null === e.value ? e : t.innerType._zod.run(e, i))))
-      }),
-      t_ = eb('$ZodPrefault', (e, t) => {
-        ;(e7.init(e, t),
-          (e._zod.optin = 'optional'),
-          e$(e._zod, 'values', () => t.innerType._zod.values),
-          (e._zod.parse = (e, i) => (
-            'backward' === i.direction || (void 0 === e.value && (e.value = t.defaultValue)),
-            t.innerType._zod.run(e, i)
-          )))
-      }),
-      tz = eb('$ZodLazy', (e, t) => {
-        ;(e7.init(e, t),
-          e$(e._zod, 'innerType', () => t.getter()),
-          e$(e._zod, 'pattern', () => e._zod.innerType?._zod?.pattern),
-          e$(e._zod, 'propValues', () => e._zod.innerType?._zod?.propValues),
-          e$(e._zod, 'optin', () => e._zod.innerType?._zod?.optin ?? void 0),
-          e$(e._zod, 'optout', () => e._zod.innerType?._zod?.optout ?? void 0),
-          (e._zod.parse = (t, i) => e._zod.innerType._zod.run(t, i)))
-      })
-    ;(Symbol('ZodOutput'), Symbol('ZodInput'))
-    function tO(e, t) {
-      return new e4({ check: 'min_length', ...eC(t), minimum: e })
-    }
-    ;(a = globalThis).__zod_globalRegistry ??
-      (a.__zod_globalRegistry = new (class e {
-        constructor() {
-          ;((this._map = new WeakMap()), (this._idmap = new Map()))
-        }
-        add(e, ...t) {
-          let i = t[0]
-          return (
-            this._map.set(e, i),
-            i && 'object' == typeof i && 'id' in i && this._idmap.set(i.id, e),
-            this
-          )
-        }
-        clear() {
-          return ((this._map = new WeakMap()), (this._idmap = new Map()), this)
-        }
-        remove(e) {
-          let t = this._map.get(e)
-          return (
-            t && 'object' == typeof t && 'id' in t && this._idmap.delete(t.id),
-            this._map.delete(e),
-            this
-          )
-        }
-        get(e) {
-          let t = e._zod.parent
-          if (t) {
-            let i = { ...(this.get(t) ?? {}) }
-            delete i.id
-            let n = { ...i, ...this._map.get(e) }
-            return Object.keys(n).length ? n : void 0
-          }
-          return this._map.get(e)
-        }
-        has(e) {
-          return this._map.has(e)
-        }
-      })())
-    let tE = eb('ZodMiniType', (e, t) => {
-        if (!e._zod) throw Error('Uninitialized schema in ZodMiniType.')
-        ;(e7.init(e, t),
-          (e.def = t),
-          (e.type = t.type),
-          (e.parse = (t, i) => eJ(e, t, i, { callee: e.parse })),
-          (e.safeParse = (t, i) => eK(e, t, i)),
-          (e.parseAsync = async (t, i) => eH(e, t, i, { callee: e.parseAsync })),
-          (e.safeParseAsync = async (t, i) => eW(e, t, i)),
-          (e.check = (...i) =>
-            e.clone(
-              {
-                ...t,
-                checks: [
-                  ...(t.checks ?? []),
-                  ...i.map((e) =>
-                    'function' == typeof e
-                      ? { _zod: { check: e, def: { check: 'custom' }, onattach: [] } }
-                      : e,
-                  ),
-                ],
-              },
-              { parent: !0 },
-            )),
-          (e.with = e.check),
-          (e.clone = (t, i) => eM(e, t, i)),
-          (e.brand = () => e),
-          (e.register = (t, i) => (t.add(e, i), e)),
-          (e.apply = (t) => t(e)))
-      }),
-      tk = eb('ZodMiniString', (e, t) => {
-        ;(te.init(e, t), tE.init(e, t))
-      })
-    function tS(e) {
-      return new tk({ type: 'string', ...eC(e) })
-    }
-    let tx = eb('ZodMiniStringFormat', (e, t) => {
-        ;(tt.init(e, t), tk.init(e, t))
-      }),
-      t$ = eb('ZodMiniNumber', (e, t) => {
-        ;(tn.init(e, t), tE.init(e, t))
-      })
-    function tI(e) {
-      return new t$({ type: 'number', checks: [], ...eC(e) })
-    }
-    let tP = eb('ZodMiniBoolean', (e, t) => {
-      ;(tr.init(e, t), tE.init(e, t))
-    })
-    function tj(e) {
-      return new tP({ type: 'boolean', ...eC(e) })
-    }
-    let tT = eb('ZodMiniNull', (e, t) => {
-      ;(ts.init(e, t), tE.init(e, t))
-    })
-    function tF(e) {
-      return new tT({ type: 'null', ...eC(e) })
-    }
-    let tA = eb('ZodMiniAny', (e, t) => {
-      ;(to.init(e, t), tE.init(e, t))
-    })
-    function tR() {
-      return new tA({ type: 'any' })
-    }
-    let tM = eb('ZodMiniUnknown', (e, t) => {
-        ;(ta.init(e, t), tE.init(e, t))
-      }),
-      tC = eb('ZodMiniArray', (e, t) => {
-        ;(tu.init(e, t), tE.init(e, t))
-      })
-    function tB(e, t) {
-      return new tC({ type: 'array', element: e, ...eC(t) })
-    }
-    let tq = eb('ZodMiniObject', (e, t) => {
-      ;(td.init(e, t), tE.init(e, t), e$(e, 'shape', () => t.shape))
-    })
-    function tU(e, t) {
-      return new tq({ type: 'object', shape: e ?? {}, ...eC(t) })
-    }
-    function tN(e, t) {
-      if (!eF(t)) throw Error('Invalid input to extend: expected a plain object')
-      let i = e._zod.def.checks
-      if (i && i.length > 0) {
-        let i = e._zod.def.shape
-        for (let e in t)
-          if (void 0 !== Object.getOwnPropertyDescriptor(i, e))
-            throw Error(
-              'Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.',
-            )
-      }
-      let n = eP(e._zod.def, {
-        get shape() {
-          let i = { ...e._zod.def.shape, ...t }
-          return (eI(this, 'shape', i), i)
-        },
-      })
-      return eM(e, n)
-    }
-    function tV(e, t) {
-      return e.clone({ ...e._zod.def, catchall: t })
-    }
-    let tD = eb('ZodMiniUnion', (e, t) => {
-      ;(th.init(e, t), tE.init(e, t))
-    })
-    function tZ(e, t) {
-      return new tD({ type: 'union', options: e, ...eC(t) })
-    }
-    let tL = eb('ZodMiniDiscriminatedUnion', (e, t) => {
-      ;(tp.init(e, t), tE.init(e, t))
-    })
-    function tQ(e, t, i) {
-      return new tL({ type: 'union', options: t, discriminator: e, ...eC(i) })
-    }
-    let tJ = eb('ZodMiniRecord', (e, t) => {
-      ;(tv.init(e, t), tE.init(e, t))
-    })
-    function tH(e, t, i) {
-      return new tJ({ type: 'record', keyType: e, valueType: t, ...eC(i) })
-    }
-    let tK = eb('ZodMiniEnum', (e, t) => {
-      ;(ty.init(e, t), tE.init(e, t), (e.options = Object.values(t.entries)))
-    })
-    function tW(e, t) {
-      return new tK({
-        type: 'enum',
-        entries: Array.isArray(e) ? Object.fromEntries(e.map((e) => [e, e])) : e,
-        ...eC(t),
-      })
-    }
-    let tG = eb('ZodMiniLiteral', (e, t) => {
-      ;(tg.init(e, t), tE.init(e, t))
-    })
-    function tX(e, t) {
-      return new tG({ type: 'literal', values: Array.isArray(e) ? e : [e], ...eC(t) })
-    }
-    let tY = eb('ZodMiniOptional', (e, t) => {
-      ;(tb.init(e, t), tE.init(e, t))
-    })
-    function t0(e) {
-      return new tY({ type: 'optional', innerType: e })
-    }
-    let t1 = eb('ZodMiniNullable', (e, t) => {
-      ;(tw.init(e, t), tE.init(e, t))
-    })
-    function t2(e) {
-      return new t1({ type: 'nullable', innerType: e })
-    }
-    let t6 = eb('ZodMiniPrefault', (e, t) => {
-      ;(t_.init(e, t), tE.init(e, t))
-    })
-    function t3(e, t) {
-      return new t6({
-        type: 'prefault',
-        innerType: e,
-        get defaultValue() {
-          return 'function' == typeof t ? t() : eF(t) ? { ...t } : Array.isArray(t) ? [...t] : t
-        },
-      })
-    }
-    let t4 = eb('ZodMiniLazy', (e, t) => {
-      ;(tz.init(e, t), tE.init(e, t))
-    })
-    function t8() {
-      let e = new t4({
-        type: 'lazy',
-        getter: () => tZ([tS(), tI(), tj(), tF(), tB(e), tH(tS(), e)]),
-      })
-      return e
-    }
-    let t5 = eb('ZodMiniISODateTime', (e, t) => {
-      ;(ti.init(e, t), tx.init(e, t))
-    })
-    function t9(e) {
-      return new t5({
-        type: 'string',
-        format: 'datetime',
-        check: 'string_format',
-        offset: !1,
-        local: !1,
-        precision: null,
-        ...eC(e),
-      })
-    }
-    let t7 = tV(tU({}), t8()),
-      ie = tU({ sys: tU({ type: tX('Link'), linkType: tS(), id: tS() }) }),
-      it = tU({ sys: tU({ type: tX('Link'), linkType: tX('ContentType'), id: tS() }) }),
-      ii = tU({ sys: tU({ type: tX('Link'), linkType: tX('Environment'), id: tS() }) }),
-      ir = tU({ sys: tU({ type: tX('Link'), linkType: tX('Space'), id: tS() }) }),
-      is = tU({ sys: tU({ type: tX('Link'), linkType: tX('TaxonomyConcept'), id: tS() }) }),
-      io = tU({ sys: tU({ type: tX('Link'), linkType: tX('Tag'), id: tS() }) }),
-      ia = tU({
-        type: tX('Entry'),
-        contentType: it,
-        publishedVersion: tI(),
-        id: tS(),
-        createdAt: tR(),
-        updatedAt: tR(),
-        locale: t0(tS()),
-        revision: tI(),
-        space: ir,
-        environment: ii,
-      }),
-      il = tU({ fields: t7, metadata: tU({ tags: tB(io), concepts: t0(tB(is)) }), sys: ia }),
-      iu = tN(t7, { nt_audience_id: tS(), nt_name: t0(tS()), nt_description: t0(tS()) }),
-      ic = tN(il, { fields: iu })
-    tU({ contentTypeId: tX('nt_audience'), fields: iu })
-    let id = tN(il, {
-        fields: tU({ nt_name: tS(), nt_fallback: t0(tS()), nt_mergetag_id: tS() }),
-        sys: tN(ia, {
-          contentType: tU({
-            sys: tU({ type: tX('Link'), linkType: tX('ContentType'), id: tX('nt_mergetag') }),
-          }),
-        }),
-      }),
-      ih = tU({ id: tS(), hidden: t0(tj()) }),
-      ip = tU({ type: t0(tX('EntryReplacement')), baseline: ih, variants: tB(ih) }),
-      iv = tU({ value: tZ([tS(), tj(), tF(), tI(), tH(tS(), t8())]) }),
-      iy = tW(['Boolean', 'Number', 'Object', 'String']),
-      ig = tQ('type', [
-        ip,
-        tU({
-          type: tX('InlineVariable'),
-          key: tS(),
-          valueType: iy,
-          baseline: iv,
-          variants: tB(iv),
-        }),
-      ]),
-      im = tB(ig),
-      ib = tU({
-        distribution: t0(tB(tI())),
-        traffic: t0(tI()),
-        components: t0(im),
-        sticky: t0(tj()),
-      }),
-      iw = tZ([tX('nt_experiment'), tX('nt_personalization')]),
-      i_ = tN(t7, {
-        nt_name: tS(),
-        nt_description: t0(t2(tS())),
-        nt_type: iw,
-        nt_config: t0(t2(ib)),
-        nt_audience: t0(t2(ic)),
-        nt_variants: t0(tB(tZ([ie, il]))),
-        nt_experience_id: tS(),
-      }),
-      iz = tN(il, { fields: i_ })
-    tU({ contentTypeId: tX('nt_experience'), fields: i_ })
-    let iO = tN(il, { fields: tN(t7, { nt_experiences: tB(tZ([ie, iz])) }) })
-    function iE(e) {
-      return iz.safeParse(e).success
-    }
-    function ik(e) {
-      return iO.safeParse(e).success
-    }
-    let iS = t0(tU({ name: tS(), version: tS() })),
-      ix = tU({
-        name: t0(tS()),
-        source: t0(tS()),
-        medium: t0(tS()),
-        term: t0(tS()),
-        content: t0(tS()),
-      }),
-      i$ = tZ([tX('mobile'), tX('server'), tX('web')]),
-      iI = tH(tS(), tS()),
-      iP = tU({ latitude: tI(), longitude: tI() }),
-      ij = tU({
-        coordinates: t0(iP),
-        city: t0(tS()),
-        postalCode: t0(tS()),
-        region: t0(tS()),
-        regionCode: t0(tS()),
-        country: t0(tS()),
-        countryCode: t0(tS().check(new e8({ check: 'length_equals', ...eC(void 0), length: 2 }))),
-        continent: t0(tS()),
-        timezone: t0(tS()),
-      }),
-      iT = tU({ name: tS(), version: tS() }),
-      iF = tV(
-        tU({ path: tS(), query: iI, referrer: tS(), search: tS(), title: t0(tS()), url: tS() }),
-        t8(),
-      ),
-      iA = tH(tS(), t8()),
-      iR = tV(tU({ name: tS() }), t8()),
-      iM = tH(tS(), t8()),
-      iC = tU({
-        app: iS,
-        campaign: ix,
-        gdpr: tU({ isConsentGiven: tj() }),
-        library: iT,
-        locale: tS(),
-        location: t0(ij),
-        userAgent: t0(tS()),
-      }),
-      iB = tU({
-        channel: i$,
-        context: tN(iC, { page: t0(iF), screen: t0(iR) }),
-        messageId: tS(),
-        originalTimestamp: t9(),
-        sentAt: t9(),
-        timestamp: t9(),
-        userId: t0(tS()),
-      }),
-      iq = tN(iB, { type: tX('alias') }),
-      iU = tN(iB, { type: tX('group') }),
-      iN = tN(iB, { type: tX('identify'), traits: iM }),
-      iV = tN(iC, { page: iF }),
-      iD = tN(iB, { type: tX('page'), name: t0(tS()), properties: iF, context: iV }),
-      iZ = tN(iC, { screen: iR }),
-      iL = tN(iB, { type: tX('screen'), name: tS(), properties: t0(iA), context: iZ }),
-      iQ = tN(iB, { type: tX('track'), event: tS(), properties: iA }),
-      iJ = tN(iB, {
-        componentType: tZ([tX('Entry'), tX('Variable')]),
-        componentId: tS(),
-        experienceId: t0(tS()),
-        variantIndex: tI(),
-      }),
-      iH = tN(iJ, { type: tX('component'), viewDurationMs: t0(tI()), viewId: t0(tS()) }),
-      iK = { anonymousId: tS() },
-      iW = tB(
-        tQ('type', [
-          tN(iq, iK),
-          tN(iH, iK),
-          tN(iU, iK),
-          tN(iN, iK),
-          tN(iD, iK),
-          tN(iL, iK),
-          tN(iQ, iK),
-        ]),
-      ),
-      iG = tQ('type', [iq, iH, iU, iN, iD, iL, iQ]),
-      iX = tB(iG),
-      iY = tU({ features: t0(tB(tS())) }),
-      i0 = tU({ events: iX.check(tO(1)), options: t0(iY) }),
-      i1 = tU({ events: iW.check(tO(1)), options: t0(iY) }),
-      i2 = tU({
-        id: tS(),
-        isReturningVisitor: tj(),
-        landingPage: iF,
-        count: tI(),
-        activeSessionLength: tI(),
-        averageSessionLength: tI(),
-      }),
-      i6 = tU({
-        id: tS(),
-        stableId: tS(),
-        random: tI(),
-        audiences: tB(tS()),
-        traits: iM,
-        location: ij,
-        session: i2,
-      }),
-      i3 = tV(tU({ id: tS() }), t8()),
-      i4 = tU({ data: tU(), message: tS(), error: t2(tj()) }),
-      i8 = tN(i4, { data: tU({ profiles: t0(tB(i6)) }) }),
-      i5 = tU({
-        key: tS(),
-        type: tZ([tW(['Variable']), tS()]),
-        meta: tU({ experienceId: tS(), variantIndex: tI() }),
-      }),
-      i9 = tZ([tS(), tj(), tF(), tI(), tH(tS(), t8())])
-    tN(i5, { type: tS(), value: new tM({ type: 'unknown' }) })
-    let i7 = tB(tQ('type', [tN(i5, { type: tX('Variable'), value: i9 })])),
-      ne = tB(
-        tU({
-          experienceId: tS(),
-          variantIndex: tI(),
-          variants: tH(tS(), tS()),
-          sticky: t0(t3(tj(), !1)),
-        }),
-      ),
-      nt = tN(i4, { data: tU({ profile: i6, experiences: ne, changes: i7 }) }),
-      ni = tQ('type', [
-        iH,
-        tN(iJ, { type: tX('component_click') }),
-        tN(iJ, { type: tX('component_hover'), hoverDurationMs: tI(), hoverId: tS() }),
-      ]),
-      nn = tU({ profile: i3, events: tB(ni) }),
-      nr = tB(nn)
-    function ns(e, t) {
-      let i = e.safeParse(t)
-      if (i.success) return i.data
-      throw Error(
-        (function (e) {
-          let t = []
-          for (let i of [...e.issues].sort((e, t) => (e.path ?? []).length - (t.path ?? []).length))
-            (t.push(`✖ ${i.message}`),
-              i.path?.length &&
-                t.push(
-                  `  → at ${(function (e) {
-                    let t = []
-                    for (let i of e.map((e) => ('object' == typeof e ? e.key : e)))
-                      'number' == typeof i
-                        ? t.push(`[${i}]`)
-                        : 'symbol' == typeof i
-                          ? t.push(`[${JSON.stringify(String(i))}]`)
-                          : /[^\w$]/.test(i)
-                            ? t.push(`[${JSON.stringify(i)}]`)
-                            : (t.length && t.push('.'), t.push(i))
-                    return t.join('')
-                  })(i.path)}`,
-                ))
-          return t.join('\n')
-        })(i.error),
-      )
-    }
-    ez({
-      localeError:
-        ((r = {
-          string: { unit: 'characters', verb: 'to have' },
-          file: { unit: 'bytes', verb: 'to have' },
-          array: { unit: 'items', verb: 'to have' },
-          set: { unit: 'items', verb: 'to have' },
-          map: { unit: 'entries', verb: 'to have' },
-        }),
-        (s = {
-          regex: 'input',
-          email: 'email address',
-          url: 'URL',
-          emoji: 'emoji',
-          uuid: 'UUID',
-          uuidv4: 'UUIDv4',
-          uuidv6: 'UUIDv6',
-          nanoid: 'nanoid',
-          guid: 'GUID',
-          cuid: 'cuid',
-          cuid2: 'cuid2',
-          ulid: 'ULID',
-          xid: 'XID',
-          ksuid: 'KSUID',
-          datetime: 'ISO datetime',
-          date: 'ISO date',
-          time: 'ISO time',
-          duration: 'ISO duration',
-          ipv4: 'IPv4 address',
-          ipv6: 'IPv6 address',
-          mac: 'MAC address',
-          cidrv4: 'IPv4 range',
-          cidrv6: 'IPv6 range',
-          base64: 'base64-encoded string',
-          base64url: 'base64url-encoded string',
-          json_string: 'JSON string',
-          e164: 'E.164 number',
-          jwt: 'JWT',
-          template_literal: 'input',
-        }),
-        (o = { nan: 'NaN' }),
-        (e) => {
-          switch (e.code) {
-            case 'invalid_type': {
-              let t = o[e.expected] ?? e.expected,
-                i = (function (e) {
-                  let t = typeof e
-                  switch (t) {
-                    case 'number':
-                      return Number.isNaN(e) ? 'nan' : 'number'
-                    case 'object':
-                      if (null === e) return 'null'
-                      if (Array.isArray(e)) return 'array'
-                      if (
-                        e &&
-                        Object.getPrototypeOf(e) !== Object.prototype &&
-                        'constructor' in e &&
-                        e.constructor
-                      )
-                        return e.constructor.name
-                  }
-                  return t
-                })(e.input),
-                n = o[i] ?? i
-              return `Invalid input: expected ${t}, received ${n}`
-            }
-            case 'invalid_value':
-              if (1 === e.values.length) return `Invalid input: expected ${eB(e.values[0])}`
-              return `Invalid option: expected one of ${eO(e.values, '|')}`
-            case 'too_big': {
-              let t = e.inclusive ? '<=' : '<',
-                i = r[e.origin] ?? null
-              if (i)
-                return `Too big: expected ${e.origin ?? 'value'} to have ${t}${e.maximum.toString()} ${i.unit ?? 'elements'}`
-              return `Too big: expected ${e.origin ?? 'value'} to be ${t}${e.maximum.toString()}`
-            }
-            case 'too_small': {
-              let t = e.inclusive ? '>=' : '>',
-                i = r[e.origin] ?? null
-              if (i)
-                return `Too small: expected ${e.origin} to have ${t}${e.minimum.toString()} ${i.unit}`
-              return `Too small: expected ${e.origin} to be ${t}${e.minimum.toString()}`
-            }
-            case 'invalid_format':
-              if ('starts_with' === e.format) return `Invalid string: must start with "${e.prefix}"`
-              if ('ends_with' === e.format) return `Invalid string: must end with "${e.suffix}"`
-              if ('includes' === e.format) return `Invalid string: must include "${e.includes}"`
-              if ('regex' === e.format) return `Invalid string: must match pattern ${e.pattern}`
-              return `Invalid ${s[e.format] ?? e.format}`
-            case 'not_multiple_of':
-              return `Invalid number: must be a multiple of ${e.divisor}`
-            case 'unrecognized_keys':
-              return `Unrecognized key${e.keys.length > 1 ? 's' : ''}: ${eO(e.keys, ', ')}`
-            case 'invalid_key':
-              return `Invalid key in ${e.origin}`
-            case 'invalid_union':
-            default:
-              return 'Invalid input'
-            case 'invalid_element':
-              return `Invalid value in ${e.origin}`
-          }
-        }),
-    })
-    let no = new (class {
-      name = '@contentful/optimization'
-      PREFIX_PARTS = ['Ctfl', 'O10n']
-      DELIMITER = ':'
-      sinks = []
-      assembleLocationPrefix(e) {
-        return `[${[...this.PREFIX_PARTS, e].join(this.DELIMITER)}]`
-      }
-      addSink(e) {
-        this.sinks = [...this.sinks.filter((t) => t.name !== e.name), e]
-      }
-      removeSink(e) {
-        this.sinks = this.sinks.filter((t) => t.name !== e)
-      }
-      removeSinks() {
-        this.sinks = []
-      }
-      debug(e, t, ...i) {
-        this.emit('debug', e, t, ...i)
-      }
-      info(e, t, ...i) {
-        this.emit('info', e, t, ...i)
-      }
-      log(e, t, ...i) {
-        this.emit('log', e, t, ...i)
-      }
-      warn(e, t, ...i) {
-        this.emit('warn', e, t, ...i)
-      }
-      error(e, t, ...i) {
-        this.emit('error', e, t, ...i)
-      }
-      fatal(e, t, ...i) {
-        this.emit('fatal', e, t, ...i)
-      }
-      emit(e, t, i, ...n) {
-        this.onLogEvent({
-          name: this.name,
-          level: e,
-          messages: [`${this.assembleLocationPrefix(t)} ${String(i)}`, ...n],
-        })
-      }
-      onLogEvent(e) {
-        this.sinks.forEach((t) => {
-          t.ingest(e)
-        })
-      }
-    })()
-    function na(e) {
-      return {
-        debug: (t, ...i) => {
-          no.debug(e, t, ...i)
-        },
-        info: (t, ...i) => {
-          no.info(e, t, ...i)
-        },
-        log: (t, ...i) => {
-          no.log(e, t, ...i)
-        },
-        warn: (t, ...i) => {
-          no.warn(e, t, ...i)
-        },
-        error: (t, ...i) => {
-          no.error(e, t, ...i)
-        },
-        fatal: (t, ...i) => {
-          no.fatal(e, t, ...i)
-        },
-      }
-    }
-    let nl = { fatal: 60, error: 50, warn: 40, info: 30, debug: 20, log: 10 },
-      nu = class {},
-      nc = {
-        debug: (...e) => {
-          console.debug(...e)
-        },
-        info: (...e) => {
-          console.info(...e)
-        },
-        log: (...e) => {
-          console.log(...e)
-        },
-        warn: (...e) => {
-          console.warn(...e)
-        },
-        error: (...e) => {
-          console.error(...e)
-        },
-        fatal: (...e) => {
-          console.error(...e)
-        },
-      }
-    class nd extends nu {
-      name = 'ConsoleLogSink'
-      verbosity
-      constructor(e) {
-        ;(super(), (this.verbosity = e ?? 'error'))
-      }
-      ingest(e) {
-        nl[e.level] < nl[this.verbosity] || nc[e.level](...e.messages)
-      }
-    }
-    let nf = na('ApiClient:Retry')
-    class nh extends Error {
-      status
-      constructor(e, t = 500) {
-        ;(super(e), Object.setPrototypeOf(this, nh.prototype), (this.status = t))
-      }
-    }
-    async function np(e) {
-      if (e <= 0) return
-      let { promise: t, resolve: i } = Promise.withResolvers()
-      ;(setTimeout(() => {
-        i(void 0)
-      }, e),
-        await t)
-    }
-    let nv = na('ApiClient:Timeout'),
-      ny = na('ApiClient:Fetch'),
-      ng = function (e) {
-        try {
-          let t = (function ({
-            apiName: e = 'Optimization',
-            fetchMethod: t = fetch,
-            onRequestTimeout: i,
-            requestTimeout: n = 3e3,
-          } = {}) {
-            return async (r, s) => {
-              let o = new AbortController(),
-                a = setTimeout(() => {
-                  ;('function' == typeof i
-                    ? i({ apiName: e })
-                    : nv.error(`Request to "${r.toString()}" timed out`, Error('Request timeout')),
-                    o.abort())
-                }, n),
-                l = await t(r, { ...s, signal: o.signal })
-              return (clearTimeout(a), l)
-            }
-          })(e)
-          return (function ({
-            apiName: e = 'Optimization',
-            fetchMethod: t = fetch,
-            intervalTimeout: i = 0,
-            onFailedAttempt: n,
-            retries: r = 1,
-          } = {}) {
-            return async (s, o) => {
-              let a = new AbortController(),
-                l = r + 1,
-                u = (function ({
-                  apiName: e = 'Optimization',
-                  controller: t,
-                  fetchMethod: i = fetch,
-                  init: n,
-                  url: r,
-                }) {
-                  return async () => {
-                    try {
-                      let s = await i(r, n)
-                      if (503 === s.status)
-                        throw new nh(
-                          `${e} API request to "${r.toString()}" failed with status: "[${s.status}] ${s.statusText}".`,
-                          503,
-                        )
-                      if (!s.ok) {
-                        let e = Error(
-                          `Request to "${r.toString()}" failed with status: [${s.status}] ${s.statusText} - traceparent: ${s.headers.get('traceparent')}`,
-                        )
-                        ;(nf.error('Request failed with non-OK status:', e), t.abort())
-                        return
-                      }
-                      return (nf.debug(`Response from "${r.toString()}":`, s), s)
-                    } catch (e) {
-                      if (e instanceof nh && 503 === e.status) throw e
-                      ;(nf.error(`Request to "${r.toString()}" failed:`, e), t.abort())
-                    }
-                  }
-                })({ apiName: e, controller: a, fetchMethod: t, init: o, url: s })
-              for (let t = 1; t <= l; t++)
-                try {
-                  let e = await u()
-                  if (e) return e
-                  break
-                } catch (s) {
-                  if (!(s instanceof nh) || 503 !== s.status) throw s
-                  let r = l - t
-                  if ((n?.({ apiName: e, error: s, attemptNumber: t, retriesLeft: r }), 0 === r))
-                    throw s
-                  await np(i)
-                }
-              throw Error(`${e} API request to "${s.toString()}" may not be retried.`)
-            }
-          })({ ...e, fetchMethod: t })
-        } catch (e) {
-          throw (
-            e instanceof Error &&
-              ('AbortError' === e.name
-                ? ny.warn('Request aborted due to network issues. This request may not be retried.')
-                : ny.error('Request failed:', e)),
-            e
-          )
-        }
-      },
-      nm = na('ApiClient'),
-      nb = class {
-        name
-        clientId
-        environment
-        fetch
-        constructor(e, { fetchOptions: t, clientId: i, environment: n }) {
-          ;((this.clientId = i),
-            (this.environment = n ?? 'main'),
-            (this.name = e),
-            (this.fetch = ng({ ...(t ?? {}), apiName: e })))
-        }
-        logRequestError(e, { requestName: t }) {
-          e instanceof Error &&
-            ('AbortError' === e.name
-              ? nm.warn(
-                  `[${this.name}] "${t}" request aborted due to network issues. This request may not be retried.`,
-                )
-              : nm.error(`[${this.name}] "${t}" request failed:`, e))
-        }
-      },
-      nw = na('ApiClient:Experience')
-    class n_ extends nb {
-      baseUrl
-      enabledFeatures
-      ip
-      locale
-      plainText
-      preflight
-      constructor(e) {
-        super('Experience', e)
-        const { baseUrl: t, enabledFeatures: i, ip: n, locale: r, plainText: s, preflight: o } = e
-        ;((this.baseUrl = t || 'https://experience.ninetailed.co/'),
-          (this.enabledFeatures = i),
-          (this.ip = n),
-          (this.locale = r),
-          (this.plainText = s),
-          (this.preflight = o))
-      }
-      async getProfile(e, t = {}) {
-        if (!e) throw Error('Valid profile ID required.')
-        let i = 'Get Profile'
-        nw.info(`Sending "${i}" request`)
-        try {
-          let n = await this.fetch(
-              this.constructUrl(
-                `v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${e}`,
-                t,
-              ),
-              { method: 'GET' },
-            ),
-            {
-              data: { changes: r, experiences: s, profile: o },
-            } = ns(nt, await n.json())
-          return (
-            nw.debug(`"${i}" request successfully completed`),
-            { changes: r, selectedOptimizations: s, profile: o }
-          )
-        } catch (e) {
-          throw (this.logRequestError(e, { requestName: i }), e)
-        }
-      }
-      async makeProfileMutationRequest({ url: e, body: t, options: i }) {
-        return await this.fetch(this.constructUrl(e, i), {
-          method: 'POST',
-          headers: this.constructHeaders(i),
-          body: JSON.stringify(t),
-          keepalive: !0,
-        })
-      }
-      async createProfile({ events: e }, t = {}) {
-        let i = 'Create Profile'
-        nw.info(`Sending "${i}" request`)
-        let n = this.constructExperienceRequestBody(e, t)
-        nw.debug(`"${i}" request body:`, n)
-        try {
-          let e = await this.makeProfileMutationRequest({
-              url: `v2/organizations/${this.clientId}/environments/${this.environment}/profiles`,
-              body: n,
-              options: t,
-            }),
-            {
-              data: { changes: r, experiences: s, profile: o },
-            } = ns(nt, await e.json())
-          return (
-            nw.debug(`"${i}" request successfully completed`),
-            { changes: r, selectedOptimizations: s, profile: o }
-          )
-        } catch (e) {
-          throw (this.logRequestError(e, { requestName: i }), e)
-        }
-      }
-      async updateProfile({ profileId: e, events: t }, i = {}) {
-        if (!e) throw Error('Valid profile ID required.')
-        let n = 'Update Profile'
-        nw.info(`Sending "${n}" request`)
-        let r = this.constructExperienceRequestBody(t, i)
-        nw.debug(`"${n}" request body:`, r)
-        try {
-          let t = await this.makeProfileMutationRequest({
-              url: `v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${e}`,
-              body: r,
-              options: i,
-            }),
-            {
-              data: { changes: s, experiences: o, profile: a },
-            } = ns(nt, await t.json())
-          return (
-            nw.debug(`"${n}" request successfully completed`),
-            { changes: s, selectedOptimizations: o, profile: a }
-          )
-        } catch (e) {
-          throw (this.logRequestError(e, { requestName: n }), e)
-        }
-      }
-      async upsertProfile({ profileId: e, events: t }, i) {
-        return e
-          ? await this.updateProfile({ profileId: e, events: t }, i)
-          : await this.createProfile({ events: t }, i)
-      }
-      async upsertManyProfiles({ events: e }, t = {}) {
-        let i = 'Upsert Many Profiles'
-        nw.info(`Sending "${i}" request`)
-        let n = ns(i1, { events: e, options: this.constructBodyOptions(t) })
-        nw.debug(`"${i}" request body:`, n)
-        try {
-          let e = await this.makeProfileMutationRequest({
-              url: `v2/organizations/${this.clientId}/environments/${this.environment}/events`,
-              body: n,
-              options: { plainText: !1, ...t },
-            }),
-            {
-              data: { profiles: r },
-            } = ns(i8, await e.json())
-          return (nw.debug(`"${i}" request successfully completed`), r)
-        } catch (e) {
-          throw (this.logRequestError(e, { requestName: i }), e)
-        }
-      }
-      constructUrl(e, t) {
-        let i = new URL(e, this.baseUrl),
-          n = t.locale ?? this.locale,
-          r = t.preflight ?? this.preflight
-        return (
-          n && i.searchParams.set('locale', n),
-          r && i.searchParams.set('type', 'preflight'),
-          i.toString()
-        )
-      }
-      constructHeaders({ ip: e = this.ip, plainText: t = this.plainText }) {
-        let i = new Map()
-        return (
-          e && i.set('X-Force-IP', e),
-          (t ?? this.plainText ?? !0)
-            ? i.set('Content-Type', 'text/plain')
-            : i.set('Content-Type', 'application/json'),
-          Object.fromEntries(i)
-        )
-      }
-      constructBodyOptions = ({ enabledFeatures: e = this.enabledFeatures }) => {
-        let t = {}
-        return (
-          e && Array.isArray(e) && e.length > 0
-            ? (t.features = e)
-            : (t.features = ['ip-enrichment', 'location']),
-          t
-        )
-      }
-      constructExperienceRequestBody(e, t) {
-        return i0.parse({ events: ns(iX, e), options: this.constructBodyOptions(t) })
-      }
-    }
-    let nz = na('ApiClient:Insights')
-    class nO extends nb {
-      baseUrl
-      beaconHandler
-      constructor(e) {
-        super('Insights', e)
-        const { baseUrl: t, beaconHandler: i } = e
-        ;((this.baseUrl = t || 'https://ingest.insights.ninetailed.co/'), (this.beaconHandler = i))
-      }
-      async sendBatchEvents(e, t = {}) {
-        let { beaconHandler: i = this.beaconHandler } = t,
-          n = new URL(
-            `v1/organizations/${this.clientId}/environments/${this.environment}/events`,
-            this.baseUrl,
-          ),
-          r = ns(nr, e)
-        if ('function' == typeof i) {
-          if ((nz.debug('Queueing events via beaconHandler'), i(n, r))) return !0
-          nz.warn(
-            'beaconHandler failed to queue events; events will be emitted immediately via fetch',
-          )
-        }
-        let s = 'Event Batches'
-        ;(nz.info(`Sending "${s}" request`), nz.debug(`"${s}" request body:`, r))
-        try {
-          return (
-            await this.fetch(n, {
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json' },
-              body: JSON.stringify(r),
-              keepalive: !0,
-            }),
-            nz.debug(`"${s}" request successfully completed`),
-            !0
-          )
-        } catch (e) {
-          return (this.logRequestError(e, { requestName: s }), !1)
-        }
-      }
-    }
-    class nE {
-      config
-      experience
-      insights
-      constructor(e) {
-        const { experience: t, insights: i, clientId: n, environment: r, fetchOptions: s } = e,
-          o = { clientId: n, environment: r, fetchOptions: s }
-        ;((this.config = o),
-          (this.experience = new n_({ ...o, ...t })),
-          (this.insights = new nO({ ...o, ...i })))
-      }
-    }
-    function nk(e) {
-      if (!e || 'object' != typeof e) return !1
-      let t = Object.getPrototypeOf(e)
-      return (
-        (null === t || t === Object.prototype || null === Object.getPrototypeOf(t)) &&
-        '[object Object]' === Object.prototype.toString.call(e)
-      )
-    }
-    function nS(e) {
-      return nk(e) || Array.isArray(e)
-    }
-    let nx = tU({
-        campaign: t0(ix),
-        locale: t0(tS()),
-        location: t0(ij),
-        page: t0(iF),
-        screen: t0(iR),
-        userAgent: t0(tS()),
-      }),
-      n$ = tN(nx, { componentId: tS(), experienceId: t0(tS()), variantIndex: t0(tI()) }),
-      nI = tN(n$, { sticky: t0(tj()), viewId: tS(), viewDurationMs: tI() }),
-      nP = tN(n$, { viewId: t0(tS()), viewDurationMs: t0(tI()) }),
-      nj = tN(n$, { hoverId: tS(), hoverDurationMs: tI() }),
-      nT = tN(nx, { traits: t0(iM), userId: tS() }),
-      nF = tN(nx, {
-        properties: t0(
-          (function (e, t) {
-            var i = void 0
-            let n = e._zod.def.checks
-            if (n && n.length > 0)
-              throw Error('.partial() cannot be used on object schemas containing refinements')
-            let r = eP(e._zod.def, {
-              get shape() {
-                let t = e._zod.def.shape,
-                  n = { ...t }
-                if (i)
-                  for (let e in i) {
-                    if (!(e in t)) throw Error(`Unrecognized key: "${e}"`)
-                    i[e] && (n[e] = tY ? new tY({ type: 'optional', innerType: t[e] }) : t[e])
-                  }
-                else
-                  for (let e in t) n[e] = tY ? new tY({ type: 'optional', innerType: t[e] }) : t[e]
-                return (eI(this, 'shape', n), n)
-              },
-              checks: [],
-            })
-            return eM(e, r)
-          })(iF),
-        ),
-      }),
-      nA = tN(nx, { name: tS(), properties: iA }),
-      nR = tN(nx, { event: tS(), properties: t0(t3(iA, {})) }),
-      nM = { path: '', query: {}, referrer: '', search: '', title: '', url: '' },
-      nC = class {
-        app
-        channel
-        library
-        getLocale
-        getPageProperties
-        getUserAgent
-        constructor(e) {
-          const {
-            app: t,
-            channel: i,
-            library: n,
-            getLocale: r,
-            getPageProperties: s,
-            getUserAgent: o,
-          } = e
-          ;((this.app = t),
-            (this.channel = i),
-            (this.library = n),
-            (this.getLocale = r ?? (() => 'en-US')),
-            (this.getPageProperties = s ?? (() => nM)),
-            (this.getUserAgent = o ?? (() => void 0)))
-        }
-        buildUniversalEventProperties({
-          campaign: e = {},
-          locale: t,
-          location: i,
-          page: n,
-          screen: r,
-          userAgent: s,
-        }) {
-          let o = new Date().toISOString()
-          return {
-            channel: this.channel,
-            context: {
-              app: this.app,
-              campaign: e,
-              gdpr: { isConsentGiven: !0 },
-              library: this.library,
-              locale: t ?? this.getLocale() ?? 'en-US',
-              location: i,
-              page: n ?? this.getPageProperties(),
-              screen: r,
-              userAgent: s ?? this.getUserAgent(),
-            },
-            messageId: crypto.randomUUID(),
-            originalTimestamp: o,
-            sentAt: o,
-            timestamp: o,
-          }
-        }
-        buildEntryInteractionBase(e, t, i, n) {
-          return {
-            ...this.buildUniversalEventProperties(e),
-            componentType: 'Entry',
-            componentId: t,
-            experienceId: i,
-            variantIndex: n ?? 0,
-          }
-        }
-        buildView(e) {
-          let {
-            componentId: t,
-            viewId: i,
-            experienceId: n,
-            variantIndex: r,
-            viewDurationMs: s,
-            ...o
-          } = ns(nI, e)
-          return {
-            ...this.buildEntryInteractionBase(o, t, n, r),
-            type: 'component',
-            viewId: i,
-            viewDurationMs: s,
-          }
-        }
-        buildClick(e) {
-          let { componentId: t, experienceId: i, variantIndex: n, ...r } = ns(n$, e)
-          return { ...this.buildEntryInteractionBase(r, t, i, n), type: 'component_click' }
-        }
-        buildHover(e) {
-          let {
-            hoverId: t,
-            componentId: i,
-            experienceId: n,
-            hoverDurationMs: r,
-            variantIndex: s,
-            ...o
-          } = ns(nj, e)
-          return {
-            ...this.buildEntryInteractionBase(o, i, n, s),
-            type: 'component_hover',
-            hoverId: t,
-            hoverDurationMs: r,
-          }
-        }
-        buildFlagView(e) {
-          let {
-            componentId: t,
-            experienceId: i,
-            variantIndex: n,
-            viewId: r,
-            viewDurationMs: s,
-            ...o
-          } = ns(nP, e)
-          return {
-            ...this.buildEntryInteractionBase(o, t, i, n),
-            ...(void 0 === s ? {} : { viewDurationMs: s }),
-            ...(void 0 === r ? {} : { viewId: r }),
-            type: 'component',
-            componentType: 'Variable',
-          }
-        }
-        buildIdentify(e) {
-          let { traits: t = {}, userId: i, ...n } = ns(nT, e)
-          return {
-            ...this.buildUniversalEventProperties(n),
-            type: 'identify',
-            traits: t,
-            userId: i,
-          }
-        }
-        buildPageView(e = {}) {
-          let { properties: t = {}, ...i } = ns(nF, e),
-            n = this.getPageProperties(),
-            r = (function e(t, i) {
-              let n = Object.keys(i)
-              for (let r = 0; r < n.length; r++) {
-                let s = n[r]
-                if ('__proto__' === s) continue
-                let o = i[s],
-                  a = t[s]
-                nS(o) && nS(a)
-                  ? (t[s] = e(a, o))
-                  : Array.isArray(o)
-                    ? (t[s] = e([], o))
-                    : nk(o)
-                      ? (t[s] = e({}, o))
-                      : (void 0 === a || void 0 !== o) && (t[s] = o)
-              }
-              return t
-            })({ ...n, title: n.title ?? nM.title }, t),
-            {
-              context: { screen: s, ...o },
-              ...a
-            } = this.buildUniversalEventProperties(i),
-            l = ns(iV, o)
-          return { ...a, context: l, type: 'page', properties: r }
-        }
-        buildScreenView(e) {
-          let { name: t, properties: i, ...n } = ns(nA, e),
-            {
-              context: { page: r, ...s },
-              ...o
-            } = this.buildUniversalEventProperties(n),
-            a = ns(iZ, { ...s, screen: s.screen ?? { name: t } })
-          return { ...o, context: a, type: 'screen', name: t, properties: { name: t, ...i } }
-        }
-        buildTrack(e) {
-          let { event: t, properties: i = {}, ...n } = ns(nR, e)
-          return {
-            ...this.buildUniversalEventProperties(n),
-            type: 'track',
-            event: t,
-            properties: i,
-          }
-        }
-      }
-    class nB {
-      interceptors = new Map()
-      nextId = 0
-      add(e) {
-        let { nextId: t } = this
-        return ((this.nextId += 1), this.interceptors.set(t, e), t)
-      }
-      remove(e) {
-        return this.interceptors.delete(e)
-      }
-      clear() {
-        this.interceptors.clear()
-      }
-      count() {
-        return this.interceptors.size
-      }
-      async run(e) {
-        let t = Array.from(this.interceptors.values()),
-          i = e
-        for (let e of t) i = await e(es(i))
-        return i
-      }
-    }
-    let nq = {
-        resolve: (e) =>
-          e
-            ? e.reduce((e, { key: t, value: i }) => {
-                let n =
-                  'object' == typeof i && null !== i && 'value' in i && 'object' == typeof i.value
-                    ? i.value
-                    : i
-                return ((e[t] = n), e)
-              }, {})
-            : {},
-      },
-      nU = na('Optimization'),
-      nN = 'Could not resolve Merge Tag value:',
-      nV = (e, t) => {
-        if (!e || 'object' != typeof e) return
-        if (!t) return e
-        let i = e
-        for (let e of t.split('.').filter(Boolean)) {
-          if (!i || ('object' != typeof i && 'function' != typeof i)) return
-          i = Reflect.get(i, e)
-        }
-        return i
-      },
-      nD = {
-        normalizeSelectors: (e) =>
-          e
-            .split('_')
-            .map((e, t, i) =>
-              [i.slice(0, t).join('.'), i.slice(t).join('_')].filter((e) => '' !== e).join('.'),
-            ),
-        getValueFromProfile(e, t) {
-          let i = nD.normalizeSelectors(e).find((e) => nV(t, e))
-          if (!i) return
-          let n = nV(t, i)
-          if (n && ('string' == typeof n || 'number' == typeof n || 'boolean' == typeof n))
-            return `${n}`
-        },
-        resolve(e, t) {
-          if (!id.safeParse(e).success)
-            return void nU.warn(`${nN} supplied entry is not a Merge Tag entry`)
-          let {
-            fields: { nt_fallback: i },
-          } = e
-          return i6.safeParse(t).success
-            ? (nD.getValueFromProfile(e.fields.nt_mergetag_id, t) ?? i)
-            : (nU.warn(`${nN} no valid profile`), i)
-        },
-      },
-      nZ = na('Optimization'),
-      nL = 'Could not resolve optimized entry variant:',
-      nQ = {
-        getOptimizationEntry({ optimizedEntry: e, selectedOptimizations: t }, i = !1) {
-          if (i || (t.length && ik(e)))
-            return e.fields.nt_experiences
-              .filter((e) => iE(e))
-              .find((e) => t.some(({ experienceId: t }) => t === e.fields.nt_experience_id))
-        },
-        getSelectedOptimization({ optimizationEntry: e, selectedOptimizations: t }, i = !1) {
-          if (i || (t.length && iE(e)))
-            return t.find(({ experienceId: t }) => t === e.fields.nt_experience_id)
-        },
-        getSelectedVariant(
-          { optimizedEntry: e, optimizationEntry: t, selectedVariantIndex: i },
-          n = !1,
-        ) {
-          var r
-          if (!n && (!ik(e) || !iE(t))) return
-          let s = ((r = t.fields.nt_config),
-          {
-            distribution: r?.distribution === void 0 ? [] : [...r.distribution],
-            traffic: r?.traffic ?? 0,
-            components: r?.components === void 0 ? [] : [...r.components],
-            sticky: r?.sticky ?? !1,
-          }).components
-            .filter(
-              (e) => ('EntryReplacement' === e.type || void 0 === e.type) && !e.baseline.hidden,
-            )
-            .find((t) => t.baseline.id === e.sys.id)?.variants
-          if (s?.length) return s.at(i - 1)
-        },
-        getSelectedVariantEntry({ optimizationEntry: e, selectedVariant: t }, i = !1) {
-          if (!i && (!iE(e) || !ih.safeParse(t).success)) return
-          let n = e.fields.nt_variants?.find((e) => e.sys.id === t.id)
-          return il.safeParse(n).success ? n : void 0
-        },
-        resolve: function (e, t) {
-          if ((nZ.debug(`Resolving optimized entry for baseline entry ${e.sys.id}`), !t?.length))
-            return (
-              nZ.warn(`${nL} no selectedOptimizations exist for the current profile`),
-              { entry: e }
-            )
-          if (!ik(e)) return (nZ.warn(`${nL} entry ${e.sys.id} is not optimized`), { entry: e })
-          let i = nQ.getOptimizationEntry({ optimizedEntry: e, selectedOptimizations: t }, !0)
-          if (!i)
-            return (
-              nZ.warn(`${nL} could not find an optimization entry for ${e.sys.id}`),
-              { entry: e }
-            )
-          let n = nQ.getSelectedOptimization(
-              { optimizationEntry: i, selectedOptimizations: t },
-              !0,
-            ),
-            r = n?.variantIndex ?? 0
-          if (0 === r)
-            return (
-              nZ.debug(`Resolved optimization entry for entry ${e.sys.id} is baseline`),
-              { entry: e }
-            )
-          let s = nQ.getSelectedVariant(
-            { optimizedEntry: e, optimizationEntry: i, selectedVariantIndex: r },
-            !0,
-          )
-          if (!s)
-            return (
-              nZ.warn(`${nL} could not find a valid replacement variant entry for ${e.sys.id}`),
-              { entry: e }
-            )
-          let o = nQ.getSelectedVariantEntry({ optimizationEntry: i, selectedVariant: s }, !0)
-          return o
-            ? (nZ.debug(`Entry ${e.sys.id} has been resolved to variant entry ${o.sys.id}`),
-              { entry: o, selectedOptimization: n })
-            : (nZ.warn(`${nL} could not find a valid replacement variant entry for ${e.sys.id}`),
-              { entry: e })
-        },
-      }
-    class nJ {
-      api
-      eventBuilder
-      config
-      flagsResolver = nq
-      mergeTagValueResolver = nD
-      optimizedEntryResolver = nQ
-      interceptors = { event: new nB(), state: new nB() }
-      constructor(e, t = {}) {
-        this.config = e
-        const { eventBuilder: i, logLevel: n, environment: r, clientId: s, fetchOptions: o } = e
-        no.addSink(new nd(n))
-        const a = {
-          clientId: s,
-          environment: r,
-          fetchOptions: o,
-          experience: t.experience,
-          insights: t.insights,
-        }
-        ;((this.api = new nE(a)),
-          (this.eventBuilder = new nC(
-            i ?? {
-              channel: 'server',
-              library: { name: '@contentful/optimization-ios-bridge', version: '0.0.0' },
-            },
-          )))
-      }
-      getFlag(e, t) {
-        return this.flagsResolver.resolve(t)[e]
-      }
-      resolveOptimizedEntry(e, t) {
-        return this.optimizedEntryResolver.resolve(e, t)
-      }
-      getMergeTagValue(e, t) {
-        return this.mergeTagValueResolver.resolve(e, t)
-      }
-    }
-    let nH = nJ
-    function nK() {}
-    function nW(e, t) {
-      return (function e(t, i, n, r, s, o, a) {
-        let l = a(t, i, n, r, s, o)
-        if (void 0 !== l) return l
-        if (typeof t == typeof i)
-          switch (typeof t) {
-            case 'bigint':
-            case 'string':
-            case 'boolean':
-            case 'symbol':
-            case 'undefined':
-            case 'function':
-              return t === i
-            case 'number':
-              return t === i || Object.is(t, i)
-          }
-        return (function t(i, n, r, s) {
-          if (Object.is(i, n)) return !0
-          let o = A(i),
-            a = A(n)
-          if ((o === q && (o = Q), a === q && (a = Q), o !== a)) return !1
-          switch (o) {
-            case M:
-              return i.toString() === n.toString()
-            case C: {
-              let e = i.valueOf(),
-                t = n.valueOf()
-              return e === t || (Number.isNaN(e) && Number.isNaN(t))
-            }
-            case B:
-            case N:
-            case U:
-              return Object.is(i.valueOf(), n.valueOf())
-            case R:
-              return i.source === n.source && i.flags === n.flags
-            case '[object Function]':
-              return i === n
-          }
-          let l = (r = r ?? new Map()).get(i),
-            u = r.get(n)
-          if (null != l && null != u) return l === n
-          ;(r.set(i, n), r.set(n, i))
-          try {
-            switch (o) {
-              case V:
-                if (i.size !== n.size) return !1
-                for (let [t, o] of i.entries())
-                  if (!n.has(t) || !e(o, n.get(t), t, i, n, r, s)) return !1
-                return !0
-              case D: {
-                if (i.size !== n.size) return !1
-                let t = Array.from(i.values()),
-                  o = Array.from(n.values())
-                for (let a = 0; a < t.length; a++) {
-                  let l = t[a],
-                    u = o.findIndex((t) => e(l, t, void 0, i, n, r, s))
-                  if (-1 === u) return !1
-                  o.splice(u, 1)
-                }
-                return !0
-              }
-              case Z:
-              case H:
-              case K:
-              case W:
-              case G:
-              case '[object BigUint64Array]':
-              case X:
-              case Y:
-              case ee:
-              case '[object BigInt64Array]':
-              case et:
-              case ei:
-                if (
-                  ('u' > typeof Buffer && Buffer.isBuffer(i) !== Buffer.isBuffer(n)) ||
-                  i.length !== n.length
-                )
-                  return !1
-                for (let t = 0; t < i.length; t++) if (!e(i[t], n[t], t, i, n, r, s)) return !1
-                return !0
-              case L:
-                if (i.byteLength !== n.byteLength) return !1
-                return t(new Uint8Array(i), new Uint8Array(n), r, s)
-              case J:
-                if (i.byteLength !== n.byteLength || i.byteOffset !== n.byteOffset) return !1
-                return t(new Uint8Array(i), new Uint8Array(n), r, s)
-              case '[object Error]':
-                return i.name === n.name && i.message === n.message
-              case Q: {
-                if (!(t(i.constructor, n.constructor, r, s) || (nk(i) && nk(n)))) return !1
-                let o = [...Object.keys(i), ...F(i)],
-                  a = [...Object.keys(n), ...F(n)]
-                if (o.length !== a.length) return !1
-                for (let t = 0; t < o.length; t++) {
-                  let a = o[t],
-                    l = i[a]
-                  if (!Object.hasOwn(n, a)) return !1
-                  let u = n[a]
-                  if (!e(l, u, a, i, n, r, s)) return !1
-                }
-                return !0
-              }
-              default:
-                return !1
-            }
-          } finally {
-            ;(r.delete(i), r.delete(n))
-          }
-        })(t, i, o, a)
-      })(e, t, void 0, void 0, void 0, void 0, nK)
-    }
-    let nG = na('CoreStateful'),
-      nX = {
-        trackView: 'component',
-        trackFlagView: 'component',
-        trackClick: 'component_click',
-        trackHover: 'component_hover',
-      }
-    class nY extends nH {
-      flagObservables = new Map()
-      getFlag(e, t = ea.value) {
-        let i = super.getFlag(e, t),
-          n = this.buildFlagViewBuilderArgs(e, t)
-        return (
-          this.trackFlagView(n).catch((t) => {
-            no.warn(`Failed to emit "flag view" event for "${e}"`, String(t))
-          }),
-          i
-        )
-      }
-      resolveOptimizedEntry(e, t = ep.value) {
-        return super.resolveOptimizedEntry(e, t)
-      }
-      getMergeTagValue(e, t = ey.value) {
-        return super.getMergeTagValue(e, t)
-      }
-      async identify(e) {
-        let { profile: t, ...i } = e
-        return await this.sendExperienceEvent(
-          'identify',
-          [e],
-          this.eventBuilder.buildIdentify(i),
-          t,
-        )
-      }
-      async page(e = {}) {
-        let { profile: t, ...i } = e
-        return await this.sendExperienceEvent('page', [e], this.eventBuilder.buildPageView(i), t)
-      }
-      async screen(e) {
-        let { profile: t, ...i } = e
-        return await this.sendExperienceEvent(
-          'screen',
-          [e],
-          this.eventBuilder.buildScreenView(i),
-          t,
-        )
-      }
-      async track(e) {
-        let { profile: t, ...i } = e
-        return await this.sendExperienceEvent('track', [e], this.eventBuilder.buildTrack(i), t)
-      }
-      async trackView(e) {
-        let t,
-          { profile: i, ...n } = e
-        return (
-          e.sticky &&
-            (t = await this.sendExperienceEvent(
-              'trackView',
-              [e],
-              this.eventBuilder.buildView(n),
-              i,
-            )),
-          await this.sendInsightsEvent('trackView', [e], this.eventBuilder.buildView(n), i),
-          t
-        )
-      }
-      async trackClick(e) {
-        await this.sendInsightsEvent('trackClick', [e], this.eventBuilder.buildClick(e))
-      }
-      async trackHover(e) {
-        await this.sendInsightsEvent('trackHover', [e], this.eventBuilder.buildHover(e))
-      }
-      async trackFlagView(e) {
-        await this.sendInsightsEvent('trackFlagView', [e], this.eventBuilder.buildFlagView(e))
-      }
-      hasConsent(e) {
-        let { [e]: t } = nX,
-          i =
-            void 0 !== t
-              ? this.allowedEventTypes.includes(t)
-              : this.allowedEventTypes.some((t) => t === e)
-        return !!eu.value || i
-      }
-      onBlockedByConsent(e, t) {
-        ;(nG.warn(`Event "${e}" was blocked due to lack of consent; payload: ${JSON.stringify(t)}`),
-          this.reportBlockedEvent('consent', e, t))
-      }
-      async sendExperienceEvent(e, t, i, n) {
-        return this.hasConsent(e)
-          ? await this.experienceQueue.send(i)
-          : void this.onBlockedByConsent(e, t)
-      }
-      async sendInsightsEvent(e, t, i, n) {
-        this.hasConsent(e) ? await this.insightsQueue.send(i) : this.onBlockedByConsent(e, t)
-      }
-      buildFlagViewBuilderArgs(e, t = ea.value) {
-        let i = t?.find((t) => t.key === e)
-        return {
-          componentId: e,
-          experienceId: i?.meta.experienceId,
-          variantIndex: i?.meta.variantIndex,
-        }
-      }
-      getFlagObservable(e) {
-        var t
-        let i,
-          n = this.flagObservables.get(e)
-        if (n) return n
-        let r = this.trackFlagView.bind(this),
-          s = this.buildFlagViewBuilderArgs.bind(this),
-          o =
-            ((t = em.computed(() => super.getFlag(e, ea.value))),
-            (i = eo(t)),
-            {
-              get current() {
-                return i.current
-              },
-              subscribe(e) {
-                let t = !1,
-                  n = es(i.current)
-                return i.subscribe((i) => {
-                  ;(t && nW(n, i)) || ((t = !0), (n = es(i)), e(i))
-                })
-              },
-              subscribeOnce: (e) => i.subscribeOnce(e),
-            }),
-          a = {
-            get current() {
-              let { current: t } = o
-              return (
-                r(s(e, ea.value)).catch((t) => {
-                  no.warn(`Failed to emit "flag view" event for "${e}"`, String(t))
-                }),
-                t
-              )
-            },
-            subscribe: (t) =>
-              o.subscribe((i) => {
-                ;(r(s(e, ea.value)).catch((t) => {
-                  no.warn(`Failed to emit "flag view" event for "${e}"`, String(t))
-                }),
-                  t(i))
-              }),
-            subscribeOnce: (t) =>
-              o.subscribeOnce((i) => {
-                ;(r(s(e, ea.value)).catch((t) => {
-                  no.warn(`Failed to emit "flag view" event for "${e}"`, String(t))
-                }),
-                  t(i))
-              }),
-          }
-        return (this.flagObservables.set(e, a), a)
-      }
-      reportBlockedEvent(e, t, i) {
-        let n = { reason: e, method: t, args: i }
-        try {
-          this.onEventBlocked?.(n)
-        } catch (e) {
-          nG.warn(`onEventBlocked callback failed for method "${t}"`, e)
-        }
-        el.value = n
-      }
-    }
-    let n0 = nY,
-      n1 = (e, t) => (!Number.isFinite(e) || void 0 === e || e < 1 ? t : Math.floor(e)),
-      n2 = {
-        flushIntervalMs: 3e4,
-        baseBackoffMs: 500,
-        maxBackoffMs: 3e4,
-        jitterRatio: 0.2,
-        maxConsecutiveFailures: 8,
-        circuitOpenMs: 12e4,
-      },
-      n6 = '__ctfl_optimization_stateful_runtime_lock__',
-      n3 = () => {
-        let e = globalThis
-        return ((e[n6] ??= { owner: void 0 }), e[n6])
-      },
-      n4 = (e) => {
-        let t = n3()
-        t.owner === e && (t.owner = void 0)
-      }
-    class n8 {
-      circuitOpenUntil = 0
-      flushFailureCount = 0
-      flushInFlight = !1
-      nextFlushAllowedAt = 0
-      onCallbackError
-      onRetry
-      policy
-      retryTimer
-      constructor(e) {
-        const { onCallbackError: t, onRetry: i, policy: n } = e
-        ;((this.policy = n), (this.onRetry = i), (this.onCallbackError = t))
-      }
-      reset() {
-        ;(this.clearScheduledRetry(),
-          (this.circuitOpenUntil = 0),
-          (this.flushFailureCount = 0),
-          (this.flushInFlight = !1),
-          (this.nextFlushAllowedAt = 0))
-      }
-      clearScheduledRetry() {
-        void 0 !== this.retryTimer && (clearTimeout(this.retryTimer), (this.retryTimer = void 0))
-      }
-      shouldSkip(e) {
-        let { force: t, isOnline: i } = e
-        if (this.flushInFlight) return !0
-        if (t) return !1
-        if (!i) return !0
-        let n = Date.now()
-        return !!(this.nextFlushAllowedAt > n) || !!(this.circuitOpenUntil > n)
-      }
-      markFlushStarted() {
-        this.flushInFlight = !0
-      }
-      markFlushFinished() {
-        this.flushInFlight = !1
-      }
-      handleFlushSuccess() {
-        let { flushFailureCount: e } = this
-        ;(this.clearScheduledRetry(),
-          (this.circuitOpenUntil = 0),
-          (this.flushFailureCount = 0),
-          (this.nextFlushAllowedAt = 0),
-          e <= 0 || this.safeInvoke('onFlushRecovered', { consecutiveFailures: e }))
-      }
-      handleFlushFailure(e) {
-        let { queuedBatches: t, queuedEvents: i } = e
-        this.flushFailureCount += 1
-        let n = ((e) => {
-            let {
-                consecutiveFailures: t,
-                policy: { baseBackoffMs: i, jitterRatio: n, maxBackoffMs: r },
-              } = e,
-              s = Math.min(r, i * 2 ** Math.max(0, t - 1)),
-              o = s * n * Math.random()
-            return Math.round(s + o)
-          })({ consecutiveFailures: this.flushFailureCount, policy: this.policy }),
-          r = Date.now(),
-          s = {
-            consecutiveFailures: this.flushFailureCount,
-            queuedBatches: t,
-            queuedEvents: i,
-            retryDelayMs: n,
-          }
-        this.safeInvoke('onFlushFailure', s)
-        let {
-          circuitOpenUntil: o,
-          nextFlushAllowedAt: a,
-          openedCircuit: l,
-          retryDelayMs: u,
-        } = ((e) => {
-          let {
-            consecutiveFailures: t,
-            failureTimestamp: i,
-            retryDelayMs: n,
-            policy: { maxConsecutiveFailures: r, circuitOpenMs: s },
-          } = e
-          if (t < r)
-            return {
-              openedCircuit: !1,
-              retryDelayMs: n,
-              nextFlushAllowedAt: i + n,
-              circuitOpenUntil: 0,
-            }
-          let o = i + s
-          return { openedCircuit: !0, retryDelayMs: s, nextFlushAllowedAt: o, circuitOpenUntil: o }
-        })({
-          consecutiveFailures: this.flushFailureCount,
-          failureTimestamp: r,
-          retryDelayMs: n,
-          policy: this.policy,
-        })
-        ;((this.nextFlushAllowedAt = a),
-          l &&
-            ((this.circuitOpenUntil = o),
-            this.safeInvoke('onCircuitOpen', { ...s, retryDelayMs: u })),
-          this.scheduleRetry(u))
-      }
-      scheduleRetry(e) {
-        ;(this.clearScheduledRetry(),
-          (this.retryTimer = setTimeout(() => {
-            ;((this.retryTimer = void 0), this.onRetry())
-          }, e)))
-      }
-      safeInvoke(...e) {
-        let [t, i] = e
-        try {
-          if ('onFlushRecovered' === t) return void this.policy.onFlushRecovered?.(i)
-          if ('onCircuitOpen' === t) return void this.policy.onCircuitOpen?.(i)
-          this.policy.onFlushFailure?.(i)
-        } catch (e) {
-          this.onCallbackError?.(t, e)
-        }
-      }
-    }
-    let n5 = na('CoreStateful')
-    class n9 {
-      experienceApi
-      eventInterceptors
-      flushRuntime
-      getAnonymousId
-      offlineMaxEvents
-      onOfflineDrop
-      queuedExperienceEvents = new Set()
-      stateInterceptors
-      constructor(e) {
-        const {
-          experienceApi: t,
-          eventInterceptors: i,
-          flushPolicy: n,
-          getAnonymousId: r,
-          offlineMaxEvents: s,
-          onOfflineDrop: o,
-          stateInterceptors: a,
-        } = e
-        ;((this.experienceApi = t),
-          (this.eventInterceptors = i),
-          (this.getAnonymousId = r),
-          (this.offlineMaxEvents = s),
-          (this.onOfflineDrop = o),
-          (this.stateInterceptors = a),
-          (this.flushRuntime = new n8({
-            policy: n,
-            onRetry: () => {
-              this.flush()
-            },
-            onCallbackError: (e, t) => {
-              n5.warn(`Experience flush policy callback "${e}" failed`, t)
-            },
-          })))
-      }
-      clearScheduledRetry() {
-        this.flushRuntime.clearScheduledRetry()
-      }
-      async send(e) {
-        let t = ns(iG, await this.eventInterceptors.run(e))
-        if (((ec.value = t), ed.value)) return await this.upsertProfile([t])
-        ;(n5.debug(`Queueing ${t.type} event`, t), this.enqueueEvent(t))
-      }
-      async flush(e = {}) {
-        let { force: t = !1 } = e
-        if (this.flushRuntime.shouldSkip({ force: t, isOnline: !!ed.value })) return
-        if (0 === this.queuedExperienceEvents.size)
-          return void this.flushRuntime.clearScheduledRetry()
-        n5.debug('Flushing offline Experience event queue')
-        let i = Array.from(this.queuedExperienceEvents)
-        this.flushRuntime.markFlushStarted()
-        try {
-          ;(await this.tryUpsertQueuedEvents(i))
-            ? (i.forEach((e) => {
-                this.queuedExperienceEvents.delete(e)
-              }),
-              this.flushRuntime.handleFlushSuccess())
-            : this.flushRuntime.handleFlushFailure({
-                queuedBatches: +(this.queuedExperienceEvents.size > 0),
-                queuedEvents: this.queuedExperienceEvents.size,
-              })
-        } finally {
-          this.flushRuntime.markFlushFinished()
-        }
-      }
-      enqueueEvent(e) {
-        let t = []
-        if (this.queuedExperienceEvents.size >= this.offlineMaxEvents) {
-          let e = this.queuedExperienceEvents.size - this.offlineMaxEvents + 1
-          ;(t = this.dropOldestEvents(e)).length > 0 &&
-            n5.warn(
-              `Dropped ${t.length} oldest offline event(s) due to queue limit (${this.offlineMaxEvents})`,
-            )
-        }
-        ;(this.queuedExperienceEvents.add(e),
-          t.length > 0 &&
-            this.invokeOfflineDropCallback({
-              droppedCount: t.length,
-              droppedEvents: t,
-              maxEvents: this.offlineMaxEvents,
-              queuedEvents: this.queuedExperienceEvents.size,
-            }))
-      }
-      dropOldestEvents(e) {
-        let t = []
-        for (let i = 0; i < e; i += 1) {
-          let e = this.queuedExperienceEvents.values().next()
-          if (e.done) break
-          ;(this.queuedExperienceEvents.delete(e.value), t.push(e.value))
-        }
-        return t
-      }
-      invokeOfflineDropCallback(e) {
-        try {
-          this.onOfflineDrop?.(e)
-        } catch (e) {
-          n5.warn('Offline queue drop callback failed', e)
-        }
-      }
-      async tryUpsertQueuedEvents(e) {
-        try {
-          return (await this.upsertProfile(e), !0)
-        } catch (e) {
-          return (n5.warn('Experience queue flush request threw an error', e), !1)
-        }
-      }
-      async upsertProfile(e) {
-        let t = this.getAnonymousId()
-        t && n5.debug(`Anonymous ID found: ${t}`)
-        let i = await this.experienceApi.upsertProfile({ profileId: t ?? ey.value?.id, events: e })
-        return (await this.updateOutputSignals(i), i)
-      }
-      async updateOutputSignals(e) {
-        let {
-          changes: t,
-          profile: i,
-          selectedOptimizations: n,
-        } = await this.stateInterceptors.run(e)
-        f(() => {
-          ;(nW(ea.value, t) || (ea.value = t),
-            nW(ey.value, i) || (ey.value = i),
-            nW(ep.value, n) || (ep.value = n))
-        })
-      }
-    }
-    let n7 = na('CoreStateful')
-    class re {
-      eventInterceptors
-      flushIntervalMs
-      flushRuntime
-      insightsApi
-      queuedInsightsByProfile = new Map()
-      insightsPeriodicFlushTimer
-      constructor(e) {
-        const { eventInterceptors: t, flushPolicy: i, insightsApi: n } = e,
-          { flushIntervalMs: r } = i
-        ;((this.eventInterceptors = t),
-          (this.flushIntervalMs = r),
-          (this.insightsApi = n),
-          (this.flushRuntime = new n8({
-            policy: i,
-            onRetry: () => {
-              this.flush()
-            },
-            onCallbackError: (e, t) => {
-              n7.warn(`Insights flush policy callback "${e}" failed`, t)
-            },
-          })))
-      }
-      clearScheduledRetry() {
-        this.flushRuntime.clearScheduledRetry()
-      }
-      clearPeriodicFlushTimer() {
-        void 0 !== this.insightsPeriodicFlushTimer &&
-          (clearInterval(this.insightsPeriodicFlushTimer),
-          (this.insightsPeriodicFlushTimer = void 0))
-      }
-      async send(e) {
-        let { value: t } = ey
-        if (!t) return void n7.warn('Attempting to emit an event without an Optimization profile')
-        let i = ns(ni, await this.eventInterceptors.run(e))
-        n7.debug(`Queueing ${i.type} event for profile ${t.id}`, i)
-        let n = this.queuedInsightsByProfile.get(t.id)
-        ;((ec.value = i),
-          n
-            ? ((n.profile = t), n.events.push(i))
-            : this.queuedInsightsByProfile.set(t.id, { profile: t, events: [i] }),
-          this.ensurePeriodicFlushTimer(),
-          this.getQueuedEventCount() >= 25 && (await this.flush()),
-          this.reconcilePeriodicFlushTimer())
-      }
-      async flush(e = {}) {
-        let { force: t = !1 } = e
-        if (this.flushRuntime.shouldSkip({ force: t, isOnline: !!ed.value })) return
-        n7.debug('Flushing insights event queue')
-        let i = this.createBatches()
-        if (!i.length) {
-          ;(this.flushRuntime.clearScheduledRetry(), this.reconcilePeriodicFlushTimer())
-          return
-        }
-        this.flushRuntime.markFlushStarted()
-        try {
-          ;(await this.trySendBatches(i))
-            ? (this.queuedInsightsByProfile.clear(), this.flushRuntime.handleFlushSuccess())
-            : this.flushRuntime.handleFlushFailure({
-                queuedBatches: i.length,
-                queuedEvents: this.getQueuedEventCount(),
-              })
-        } finally {
-          ;(this.flushRuntime.markFlushFinished(), this.reconcilePeriodicFlushTimer())
-        }
-      }
-      createBatches() {
-        let e = []
-        return (
-          this.queuedInsightsByProfile.forEach(({ profile: t, events: i }) => {
-            e.push({ profile: t, events: i })
-          }),
-          e
-        )
-      }
-      async trySendBatches(e) {
-        try {
-          return await this.insightsApi.sendBatchEvents(e)
-        } catch (e) {
-          return (n7.warn('Insights queue flush request threw an error', e), !1)
-        }
-      }
-      getQueuedEventCount() {
-        let e = 0
-        return (
-          this.queuedInsightsByProfile.forEach(({ events: t }) => {
-            e += t.length
-          }),
-          e
-        )
-      }
-      ensurePeriodicFlushTimer() {
-        void 0 !== this.insightsPeriodicFlushTimer ||
-          (0 !== this.getQueuedEventCount() &&
-            (this.insightsPeriodicFlushTimer = setInterval(() => {
-              this.flush()
-            }, this.flushIntervalMs)))
-      }
-      reconcilePeriodicFlushTimer() {
-        this.getQueuedEventCount() > 0
-          ? this.ensurePeriodicFlushTimer()
-          : this.clearPeriodicFlushTimer()
-      }
-    }
-    let rt = Symbol.for('ctfl.optimization.preview.signals'),
-      ri = Symbol.for('ctfl.optimization.preview.signalFns'),
-      rn = na('CoreStateful'),
-      rr = ['identify', 'page', 'screen'],
-      rs = (e) => Object.values(e).some((e) => void 0 !== e),
-      ro = 0
-    class ra extends n0 {
-      singletonOwner
-      destroyed = !1
-      allowedEventTypes
-      experienceQueue
-      insightsQueue
-      onEventBlocked
-      states = {
-        blockedEventStream: eo(el),
-        flag: (e) => this.getFlagObservable(e),
-        consent: eo(eu),
-        eventStream: eo(ec),
-        canOptimize: eo(ev),
-        selectedOptimizations: eo(ep),
-        previewPanelAttached: eo(ef),
-        previewPanelOpen: eo(eh),
-        profile: eo(ey),
-      }
-      constructor(e) {
-        ;(super(e, {
-          experience: ((e) => {
-            if (void 0 === e) return
-            let t = {
-              baseUrl: e.experienceBaseUrl,
-              enabledFeatures: e.enabledFeatures,
-              ip: e.ip,
-              locale: e.locale,
-              plainText: e.plainText,
-              preflight: e.preflight,
-            }
-            return rs(t) ? t : void 0
-          })(e.api),
-          insights: ((e) => {
-            if (void 0 === e) return
-            let t = { baseUrl: e.insightsBaseUrl, beaconHandler: e.beaconHandler }
-            return rs(t) ? t : void 0
-          })(e.api),
-        }),
-          (this.singletonOwner = `CoreStateful#${++ro}`),
-          ((e) => {
-            let t = n3()
-            if (t.owner)
-              throw Error(
-                `Stateful Optimization SDK already initialized (${t.owner}). Only one stateful instance is supported per runtime.`,
-              )
-            t.owner = e
-          })(this.singletonOwner))
-        try {
-          const {
-              allowedEventTypes: t,
-              defaults: i,
-              getAnonymousId: n,
-              onEventBlocked: r,
-              queuePolicy: s,
-            } = e,
-            { changes: o, consent: a, selectedOptimizations: l, profile: u } = i ?? {},
-            c = ((e) => ({
-              flush: ((e, t = n2) => {
-                var i, n
-                let r = e ?? {},
-                  s = n1(r.baseBackoffMs, t.baseBackoffMs),
-                  o = Math.max(s, n1(r.maxBackoffMs, t.maxBackoffMs))
-                return {
-                  flushIntervalMs: n1(r.flushIntervalMs, t.flushIntervalMs),
-                  baseBackoffMs: s,
-                  maxBackoffMs: o,
-                  jitterRatio:
-                    ((i = r.jitterRatio),
-                    (n = t.jitterRatio),
-                    Number.isFinite(i) && void 0 !== i ? Math.min(1, Math.max(0, i)) : n),
-                  maxConsecutiveFailures: n1(r.maxConsecutiveFailures, t.maxConsecutiveFailures),
-                  circuitOpenMs: n1(r.circuitOpenMs, t.circuitOpenMs),
-                  onCircuitOpen: r.onCircuitOpen,
-                  onFlushFailure: r.onFlushFailure,
-                  onFlushRecovered: r.onFlushRecovered,
-                }
-              })(e?.flush),
-              offlineMaxEvents: n1(e?.offlineMaxEvents, 100),
-              onOfflineDrop: e?.onOfflineDrop,
-            }))(s)
-          ;((this.allowedEventTypes = t ?? rr),
-            (this.onEventBlocked = r),
-            (this.insightsQueue = new re({
-              eventInterceptors: this.interceptors.event,
-              flushPolicy: c.flush,
-              insightsApi: this.api.insights,
-            })),
-            (this.experienceQueue = new n9({
-              experienceApi: this.api.experience,
-              eventInterceptors: this.interceptors.event,
-              flushPolicy: c.flush,
-              getAnonymousId: n ?? (() => void 0),
-              offlineMaxEvents: c.offlineMaxEvents,
-              onOfflineDrop: c.onOfflineDrop,
-              stateInterceptors: this.interceptors.state,
-            })),
-            void 0 !== a && (eu.value = a),
-            f(() => {
-              ;(void 0 !== o && (ea.value = o),
-                void 0 !== l && (ep.value = l),
-                void 0 !== u && (ey.value = u))
-            }),
-            this.initializeEffects())
-        } catch (e) {
-          throw (n4(this.singletonOwner), e)
-        }
-      }
-      initializeEffects() {
-        ;(T(() => {
-          rn.debug(
-            `Profile ${ey.value && `with ID ${ey.value.id}`} has been ${ey.value ? 'set' : 'cleared'}`,
-          )
-        }),
-          T(() => {
-            rn.debug(`Variants have been ${ep.value?.length ? 'populated' : 'cleared'}`)
-          }),
-          T(() => {
-            rn.info(
-              `Core ${eu.value ? 'will' : 'will not'} emit gated events due to consent (${eu.value})`,
-            )
-          }),
-          T(() => {
-            ed.value &&
-              (this.insightsQueue.clearScheduledRetry(),
-              this.experienceQueue.clearScheduledRetry(),
-              this.flushQueues({ force: !0 }))
-          }))
-      }
-      async flushQueues(e = {}) {
-        ;(await this.insightsQueue.flush(e), await this.experienceQueue.flush(e))
-      }
-      destroy() {
-        this.destroyed ||
-          ((this.destroyed = !0),
-          this.insightsQueue.flush({ force: !0 }).catch((e) => {
-            no.warn('Failed to flush insights queue during destroy()', String(e))
-          }),
-          this.experienceQueue.flush({ force: !0 }).catch((e) => {
-            no.warn('Failed to flush Experience queue during destroy()', String(e))
-          }),
-          this.insightsQueue.clearPeriodicFlushTimer(),
-          n4(this.singletonOwner))
-      }
-      reset() {
-        f(() => {
-          ;((el.value = void 0),
-            (ec.value = void 0),
-            (ea.value = void 0),
-            (ey.value = void 0),
-            (ep.value = void 0))
-        })
-      }
-      async flush() {
-        await this.flushQueues()
-      }
-      consent(e) {
-        eu.value = e
-      }
-      get online() {
-        return ed.value ?? !1
-      }
-      set online(e) {
-        ed.value = e
-      }
-      registerPreviewPanel(e) {
-        ;(Reflect.set(e, rt, eg), Reflect.set(e, ri, em))
-      }
-    }
-    let rl = null,
-      ru = null,
-      rc = null,
-      rd = new Map(),
-      rf = new Map(),
-      rh = new Map(),
-      rp = new Map()
-    function rv() {
-      ;(rd.clear(), rf.clear(), rh.clear(), rp.clear())
-    }
-    let ry = {
-      initialize(e) {
-        ;(rl && ry.destroy(),
-          (rl = new ra({
-            clientId: e.clientId,
-            environment: e.environment,
-            api: { experienceBaseUrl: e.experienceBaseUrl, insightsBaseUrl: e.insightsBaseUrl },
-          })),
-          e.defaults &&
-            (void 0 !== e.defaults.consent && rl.consent(e.defaults.consent),
-            void 0 !== e.defaults.profile && (eg.profile.value = e.defaults.profile),
-            void 0 !== e.defaults.changes && (eg.changes.value = e.defaults.changes),
-            void 0 !== e.defaults.optimizations &&
-              (eg.selectedOptimizations.value = e.defaults.optimizations)),
-          rl.consent(!0))
-        let t = globalThis
-        ;((ru = T(() => {
-          let e = {
-            profile: eg.profile.value ?? null,
-            consent: eg.consent.value,
-            canPersonalize: eg.canOptimize.value,
-            changes: eg.changes.value ?? null,
-            selectedPersonalizations: eg.selectedOptimizations.value ?? null,
-          }
-          'function' == typeof t.__nativeOnStateChange && t.__nativeOnStateChange(JSON.stringify(e))
-        })),
-          (rc = T(() => {
-            let e = eg.event.value
-            e &&
-              'function' == typeof t.__nativeOnEventEmitted &&
-              t.__nativeOnEventEmitted(JSON.stringify(e))
-          })))
-      },
-      identify(e, t, i) {
-        rl
-          ? rl
-              .identify(e)
-              .then((e) => {
-                t(JSON.stringify(e ?? null))
-              })
-              .catch((e) => {
-                i(e instanceof Error ? e.message : String(e))
-              })
-          : i('SDK not initialized. Call initialize() first.')
-      },
-      page(e, t, i) {
-        rl
-          ? rl
-              .page(e)
-              .then((e) => {
-                t(JSON.stringify(e ?? null))
-              })
-              .catch((e) => {
-                i(e instanceof Error ? e.message : String(e))
-              })
-          : i('SDK not initialized. Call initialize() first.')
-      },
-      screen(e, t, i) {
-        rl
-          ? rl
-              .screen({ name: e.name, properties: e.properties ?? {} })
-              .then((e) => {
-                t(JSON.stringify(e ?? null))
-              })
-              .catch((e) => {
-                i(e instanceof Error ? e.message : String(e))
-              })
-          : i('SDK not initialized. Call initialize() first.')
-      },
-      flush(e, t) {
-        rl
-          ? rl
-              .flush()
-              .then(() => {
-                e(JSON.stringify(null))
-              })
-              .catch((e) => {
-                t(e instanceof Error ? e.message : String(e))
-              })
-          : t('SDK not initialized. Call initialize() first.')
-      },
-      trackView(e, t, i) {
-        rl
-          ? rl
-              .trackView(e)
-              .then((e) => {
-                t(JSON.stringify(e ?? null))
-              })
-              .catch((e) => {
-                i(e instanceof Error ? e.message : String(e))
-              })
-          : i('SDK not initialized. Call initialize() first.')
-      },
-      trackClick(e, t, i) {
-        rl
-          ? rl
-              .trackClick(e)
-              .then(() => {
-                t(JSON.stringify(null))
-              })
-              .catch((e) => {
-                i(e instanceof Error ? e.message : String(e))
-              })
-          : i('SDK not initialized. Call initialize() first.')
-      },
-      consent(e) {
-        rl && rl.consent(e)
-      },
-      reset() {
-        rl && (rv(), rl.reset())
-      },
-      setOnline(e) {
-        eg.online.value = e
-      },
-      personalizeEntry: (e, t) =>
-        rl ? JSON.stringify(rl.resolveOptimizedEntry(e, t)) : JSON.stringify({ entry: e }),
-      setPreviewPanelOpen(e) {
-        rl && (eg.previewPanelOpen.value = e)
-      },
-      overrideAudience(e, t) {
-        if (!rl) return
-        ;(!(function (e) {
-          if (rd.has(e)) return
-          let t = (eg.changes.value ?? []).find((t) => t.audienceId === e)
-          rd.set(e, t?.qualified ?? !1)
-        })(e),
-          rh.set(e, t))
-        let i = (eg.changes.value ?? []).map((i) =>
-          i.audienceId === e ? { ...i, qualified: t } : i,
-        )
-        eg.changes.value = i
-      },
-      overrideVariant(e, t) {
-        if (!rl) return
-        ;(!(function (e) {
-          if (rf.has(e)) return
-          let t = (eg.selectedOptimizations.value ?? []).find((t) => t.experienceId === e)
-          rf.set(e, t?.variantIndex ?? 0)
-        })(e),
-          rp.set(e, t))
-        let i = (eg.selectedOptimizations.value ?? []).map((i) =>
-          i.experienceId === e ? { ...i, variantIndex: t } : i,
-        )
-        eg.selectedOptimizations.value = i
-      },
-      resetAudienceOverride(e) {
-        if (!rl) return
-        let t = rd.get(e)
-        if (void 0 === t) return
-        rh.delete(e)
-        let i = (eg.changes.value ?? []).map((i) =>
-          i.audienceId === e ? { ...i, qualified: t } : i,
-        )
-        eg.changes.value = i
-      },
-      resetVariantOverride(e) {
-        if (!rl) return
-        let t = rf.get(e)
-        if (void 0 === t) return
-        rp.delete(e)
-        let i = (eg.selectedOptimizations.value ?? []).map((i) =>
-          i.experienceId === e ? { ...i, variantIndex: t } : i,
-        )
-        eg.selectedOptimizations.value = i
-      },
-      resetAllOverrides() {
-        if (!rl) return
-        let e = (eg.changes.value ?? []).map((e) => {
-          let t = e.audienceId
-          return t && rd.has(t) ? { ...e, qualified: rd.get(t) } : e
-        })
-        eg.changes.value = e
-        let t = (eg.selectedOptimizations.value ?? []).map((e) => {
-          let t = e.experienceId
-          return t && rf.has(t) ? { ...e, variantIndex: rf.get(t) } : e
-        })
-        ;((eg.selectedOptimizations.value = t), rv())
-      },
-      getPreviewState() {
-        let e = {}
-        rh.forEach((t, i) => {
-          e[i] = t
-        })
-        let t = {}
-        rp.forEach((e, i) => {
-          t[i] = e
-        })
-        let i = {}
-        rd.forEach((e, t) => {
-          i[t] = e
-        })
-        let n = {}
-        return (
-          rf.forEach((e, t) => {
-            n[t] = e
-          }),
-          JSON.stringify({
-            profile: eg.profile.value ?? null,
-            consent: eg.consent.value,
-            canPersonalize: eg.canOptimize.value,
-            changes: eg.changes.value ?? null,
-            selectedPersonalizations: eg.selectedOptimizations.value ?? null,
-            previewPanelOpen: eg.previewPanelOpen.value,
-            audienceOverrides: e,
-            variantOverrides: t,
-            defaultAudienceQualifications: i,
-            defaultVariantIndices: n,
-          })
-        )
-      },
-      getProfile() {
-        let e = eg.profile.value
-        return e ? JSON.stringify(e) : null
-      },
-      getState: () =>
-        JSON.stringify({
-          profile: eg.profile.value ?? null,
-          consent: eg.consent.value,
-          canPersonalize: eg.canOptimize.value,
-          changes: eg.changes.value ?? null,
-          selectedPersonalizations: eg.selectedOptimizations.value ?? null,
-        }),
-      destroy() {
-        ;(rv(),
-          rc && (rc(), (rc = null)),
-          ru && (ru(), (ru = null)),
-          rl && (rl.destroy(), (rl = null)))
-      },
-    }
-    globalThis.__bridge = ry
-    let rg = ry
-    return u.default
-  })(),
-)
-//# sourceMappingURL=optimization-ios-bridge.umd.js.map
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.OptimizationBridge=t():e.OptimizationBridge=t()}(globalThis,()=>(()=>{"use strict";let e,t,i,n,r,s,o;var a,l={};l.d=(e,t)=>{for(var i in t)l.o(t,i)&&!l.o(e,i)&&Object.defineProperty(e,i,{enumerable:!0,get:t[i]})},l.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t);var u={};l.d(u,{default:()=>rk});var c=Symbol.for("preact-signals");function d(){if(g>1)g--;else{for(var e,t=!1;void 0!==y;){var i=y;for(y=void 0,m++;void 0!==i;){var n=i.o;if(i.o=void 0,i.f&=-3,!(8&i.f)&&O(i))try{i.c()}catch(i){t||(e=i,t=!0)}i=n}}if(m=0,g--,t)throw e}}function p(e){if(g>0)return e();g++;try{return e()}finally{d()}}var h=void 0;function f(e){var t=h;h=void 0;try{return e()}finally{h=t}}var v,y=void 0,g=0,m=0,b=0;function w(e){if(void 0!==h){var t=e.n;if(void 0===t||t.t!==h)return t={i:0,S:e,p:h.s,n:void 0,t:h,e:void 0,x:void 0,r:t},void 0!==h.s&&(h.s.n=t),h.s=t,e.n=t,32&h.f&&e.S(t),t;if(-1===t.i)return t.i=0,void 0!==t.n&&(t.n.p=t.p,void 0!==t.p&&(t.p.n=t.n),t.p=h.s,t.n=void 0,h.s.n=t,h.s=t),t}}function _(e,t){this.v=e,this.i=0,this.n=void 0,this.t=void 0,this.W=null==t?void 0:t.watched,this.Z=null==t?void 0:t.unwatched,this.name=null==t?void 0:t.name}function z(e,t){return new _(e,t)}function O(e){for(var t=e.s;void 0!==t;t=t.n)if(t.S.i!==t.i||!t.S.h()||t.S.i!==t.i)return!0;return!1}function S(e){for(var t=e.s;void 0!==t;t=t.n){var i=t.S.n;if(void 0!==i&&(t.r=i),t.S.n=t,t.i=-1,void 0===t.n){e.s=t;break}}}function E(e){for(var t=e.s,i=void 0;void 0!==t;){var n=t.p;-1===t.i?(t.S.U(t),void 0!==n&&(n.n=t.n),void 0!==t.n&&(t.n.p=n)):i=t,t.S.n=t.r,void 0!==t.r&&(t.r=void 0),t=n}e.s=i}function x(e,t){_.call(this,void 0),this.x=e,this.s=void 0,this.g=b-1,this.f=4,this.W=null==t?void 0:t.watched,this.Z=null==t?void 0:t.unwatched,this.name=null==t?void 0:t.name}function k(e,t){return new x(e,t)}function I(e){var t=e.u;if(e.u=void 0,"function"==typeof t){g++;var i=h;h=void 0;try{t()}catch(t){throw e.f&=-2,e.f|=8,$(e),t}finally{h=i,d()}}}function $(e){for(var t=e.s;void 0!==t;t=t.n)t.S.U(t);e.x=void 0,e.s=void 0,I(e)}function P(e){if(h!==this)throw Error("Out-of-order effect");E(this),h=e,this.f&=-2,8&this.f&&$(this),d()}function j(e,t){this.x=e,this.u=void 0,this.s=void 0,this.o=void 0,this.f=32,this.name=null==t?void 0:t.name,v&&v.push(this)}function A(e,t){var i=new j(e,t);try{i.c()}catch(e){throw i.d(),e}var n=i.d.bind(i);return n[Symbol.dispose]=n,n}function T(e){return Object.getOwnPropertySymbols(e).filter(t=>Object.prototype.propertyIsEnumerable.call(e,t))}function F(e){return null==e?void 0===e?"[object Undefined]":"[object Null]":Object.prototype.toString.call(e)}_.prototype.brand=c,_.prototype.h=function(){return!0},_.prototype.S=function(e){var t=this,i=this.t;i!==e&&void 0===e.e&&(e.x=i,this.t=e,void 0!==i?i.e=e:f(function(){var e;null==(e=t.W)||e.call(t)}))},_.prototype.U=function(e){var t=this;if(void 0!==this.t){var i=e.e,n=e.x;void 0!==i&&(i.x=n,e.e=void 0),void 0!==n&&(n.e=i,e.x=void 0),e===this.t&&(this.t=n,void 0===n&&f(function(){var e;null==(e=t.Z)||e.call(t)}))}},_.prototype.subscribe=function(e){var t=this;return A(function(){var i=t.value,n=h;h=void 0;try{e(i)}finally{h=n}},{name:"sub"})},_.prototype.valueOf=function(){return this.value},_.prototype.toString=function(){return this.value+""},_.prototype.toJSON=function(){return this.value},_.prototype.peek=function(){var e=h;h=void 0;try{return this.value}finally{h=e}},Object.defineProperty(_.prototype,"value",{get:function(){var e=w(this);return void 0!==e&&(e.i=this.i),this.v},set:function(e){if(e!==this.v){if(m>100)throw Error("Cycle detected");this.v=e,this.i++,b++,g++;try{for(var t=this.t;void 0!==t;t=t.x)t.t.N()}finally{d()}}}}),x.prototype=new _,x.prototype.h=function(){if(this.f&=-3,1&this.f)return!1;if(32==(36&this.f)||(this.f&=-5,this.g===b))return!0;if(this.g=b,this.f|=1,this.i>0&&!O(this))return this.f&=-2,!0;var e=h;try{S(this),h=this;var t=this.x();(16&this.f||this.v!==t||0===this.i)&&(this.v=t,this.f&=-17,this.i++)}catch(e){this.v=e,this.f|=16,this.i++}return h=e,E(this),this.f&=-2,!0},x.prototype.S=function(e){if(void 0===this.t){this.f|=36;for(var t=this.s;void 0!==t;t=t.n)t.S.S(t)}_.prototype.S.call(this,e)},x.prototype.U=function(e){if(void 0!==this.t&&(_.prototype.U.call(this,e),void 0===this.t)){this.f&=-33;for(var t=this.s;void 0!==t;t=t.n)t.S.U(t)}},x.prototype.N=function(){if(!(2&this.f)){this.f|=6;for(var e=this.t;void 0!==e;e=e.x)e.t.N()}},Object.defineProperty(x.prototype,"value",{get:function(){if(1&this.f)throw Error("Cycle detected");var e=w(this);if(this.h(),void 0!==e&&(e.i=this.i),16&this.f)throw this.v;return this.v}}),j.prototype.c=function(){var e=this.S();try{if(8&this.f||void 0===this.x)return;var t=this.x();"function"==typeof t&&(this.u=t)}finally{e()}},j.prototype.S=function(){if(1&this.f)throw Error("Cycle detected");this.f|=1,this.f&=-9,I(this),S(this),g++;var e=h;return h=this,P.bind(this,e)},j.prototype.N=function(){2&this.f||(this.f|=2,this.o=y,y=this)},j.prototype.d=function(){this.f|=8,1&this.f||$(this)},j.prototype.dispose=function(){this.d()};let C="[object RegExp]",R="[object String]",M="[object Number]",B="[object Boolean]",q="[object Arguments]",U="[object Symbol]",N="[object Date]",V="[object Map]",D="[object Set]",Z="[object Array]",Q="[object ArrayBuffer]",L="[object Object]",J="[object DataView]",H="[object Uint8Array]",K="[object Uint8ClampedArray]",W="[object Uint16Array]",G="[object Uint32Array]",X="[object Int8Array]",Y="[object Int16Array]",ee="[object Int32Array]",et="[object Float32Array]",ei="[object Float64Array]",en="object"==typeof globalThis&&globalThis||"object"==typeof window&&window||"object"==typeof self&&self||"object"==typeof global&&global||function(){return this}()||Function("return this")();function er(e){return void 0!==en.Buffer&&en.Buffer.isBuffer(e)}function es(e,t,i,n=new Map,r){let s=r?.(e,t,i,n);if(void 0!==s)return s;if(null==e||"object"!=typeof e&&"function"!=typeof e)return e;if(n.has(e))return n.get(e);if(Array.isArray(e)){let t=Array(e.length);n.set(e,t);for(let s=0;s<e.length;s++)t[s]=es(e[s],s,i,n,r);return Object.hasOwn(e,"index")&&(t.index=e.index),Object.hasOwn(e,"input")&&(t.input=e.input),t}if(e instanceof Date)return new Date(e.getTime());if(e instanceof RegExp){let t=new RegExp(e.source,e.flags);return t.lastIndex=e.lastIndex,t}if(e instanceof Map){let t=new Map;for(let[s,o]of(n.set(e,t),e))t.set(s,es(o,s,i,n,r));return t}if(e instanceof Set){let t=new Set;for(let s of(n.set(e,t),e))t.add(es(s,void 0,i,n,r));return t}if(er(e))return e.subarray();if(ArrayBuffer.isView(e)&&!(e instanceof DataView)){let t=new(Object.getPrototypeOf(e)).constructor(e.length);n.set(e,t);for(let s=0;s<e.length;s++)t[s]=es(e[s],s,i,n,r);return t}if(e instanceof ArrayBuffer||"u">typeof SharedArrayBuffer&&e instanceof SharedArrayBuffer)return e.slice(0);if(e instanceof DataView){let t=new DataView(e.buffer.slice(0),e.byteOffset,e.byteLength);return n.set(e,t),eo(t,e,i,n,r),t}if("u">typeof File&&e instanceof File){let t=new File([e],e.name,{type:e.type});return n.set(e,t),eo(t,e,i,n,r),t}if("u">typeof Blob&&e instanceof Blob){let t=new Blob([e],{type:e.type});return n.set(e,t),eo(t,e,i,n,r),t}if(e instanceof Error){let t=structuredClone(e);return n.set(e,t),t.message=e.message,t.name=e.name,t.stack=e.stack,t.cause=e.cause,t.constructor=e.constructor,eo(t,e,i,n,r),t}if(e instanceof Boolean){let t=new Boolean(e.valueOf());return n.set(e,t),eo(t,e,i,n,r),t}if(e instanceof Number){let t=new Number(e.valueOf());return n.set(e,t),eo(t,e,i,n,r),t}if(e instanceof String){let t=new String(e.valueOf());return n.set(e,t),eo(t,e,i,n,r),t}if("object"==typeof e&&function(e){switch(F(e)){case q:case Z:case Q:case J:case B:case N:case et:case ei:case X:case Y:case ee:case V:case M:case L:case C:case D:case R:case U:case H:case K:case W:case G:return!0;default:return!1}}(e)){let t=Object.create(Object.getPrototypeOf(e));return n.set(e,t),eo(t,e,i,n,r),t}return e}function eo(e,t,i=e,n,r){let s=[...Object.keys(t),...T(t)];for(let o=0;o<s.length;o++){let a=s[o],l=Object.getOwnPropertyDescriptor(e,a);(null==l||l.writable)&&(e[a]=es(t[a],a,i,n,r))}}function ea(e){return es(e,void 0,e,new Map,void 0)}function el(e){return{get current(){return ea(e.value)},subscribe:t=>({unsubscribe:A(()=>{t(ea(e.value))})}),subscribeOnce(t){let i=!1,n=!1,r=()=>void 0;return r=A(()=>{if(i)return;let{value:s}=e;if(null==s)return;i=!0;let o=null;try{t(ea(s))}catch(e){o=e instanceof Error?e:Error(`Subscriber threw non-Error value: ${String(e)}`)}if(n?r():queueMicrotask(r),o)throw o}),n=!0,{unsubscribe:()=>{!i&&(i=!0,n&&r())}}}}}let eu=z(),ec=z(),ed=z(),ep=z(),eh=z(!0),ef=z(!1),ev=z(!1),ey=z(),eg=k(()=>void 0!==ey.value),em=z(),eb={blockedEvent:ec,changes:eu,consent:ed,event:ep,online:eh,previewPanelAttached:ef,previewPanelOpen:ev,selectedOptimizations:ey,canOptimize:eg,profile:em},ew={batch:p,computed:k,effect:A,untracked:f};function e_(e,t,i){function n(i,n){if(i._zod||Object.defineProperty(i,"_zod",{value:{def:n,constr:o,traits:new Set},enumerable:!1}),i._zod.traits.has(e))return;i._zod.traits.add(e),t(i,n);let r=o.prototype,s=Object.keys(r);for(let e=0;e<s.length;e++){let t=s[e];t in i||(i[t]=r[t].bind(i))}}let r=i?.Parent??Object;class s extends r{}function o(e){var t;let r=i?.Parent?new s:this;for(let i of(n(r,e),(t=r._zod).deferred??(t.deferred=[]),r._zod.deferred))i();return r}return Object.defineProperty(s,"name",{value:e}),Object.defineProperty(o,"init",{value:n}),Object.defineProperty(o,Symbol.hasInstance,{value:t=>!!i?.Parent&&t instanceof i.Parent||t?._zod?.traits?.has(e)}),Object.defineProperty(o,"name",{value:e}),o}Object.freeze({status:"aborted"}),Symbol("zod_brand");class ez extends Error{constructor(){super("Encountered Promise during synchronous parse. Use .parseAsync() instead.")}}let eO={};function eS(e){return e&&Object.assign(eO,e),eO}function eE(e,t="|"){return e.map(e=>eU(e)).join(t)}function ex(e,t){return"bigint"==typeof t?t.toString():t}function ek(e){return{get value(){{let t=e();return Object.defineProperty(this,"value",{value:t}),t}}}}function eI(e){let t=+!!e.startsWith("^"),i=e.endsWith("$")?e.length-1:e.length;return e.slice(t,i)}let e$=Symbol("evaluating");function eP(e,t,i){let n;Object.defineProperty(e,t,{get(){if(n!==e$)return void 0===n&&(n=e$,n=i()),n},set(i){Object.defineProperty(e,t,{value:i})},configurable:!0})}function ej(e,t,i){Object.defineProperty(e,t,{value:i,writable:!0,enumerable:!0,configurable:!0})}function eA(...e){let t={};for(let i of e)Object.assign(t,Object.getOwnPropertyDescriptors(i));return Object.defineProperties({},t)}let eT="captureStackTrace"in Error?Error.captureStackTrace:(...e)=>{};function eF(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function eC(e){if(!1===eF(e))return!1;let t=e.constructor;if(void 0===t||"function"!=typeof t)return!0;let i=t.prototype;return!1!==eF(i)&&!1!==Object.prototype.hasOwnProperty.call(i,"isPrototypeOf")}ek(()=>{if("u">typeof navigator&&navigator?.userAgent?.includes("Cloudflare"))return!1;try{return Function(""),!0}catch(e){return!1}});let eR=new Set(["string","number","symbol"]);function eM(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function eB(e,t,i){let n=new e._zod.constr(t??e._zod.def);return(!t||i?.parent)&&(n._zod.parent=e),n}function eq(e){if(!e)return{};if("string"==typeof e)return{error:()=>e};if(e?.message!==void 0){if(e?.error!==void 0)throw Error("Cannot specify both `message` and `error` params");e.error=e.message}return(delete e.message,"string"==typeof e.error)?{...e,error:()=>e.error}:e}function eU(e){return"bigint"==typeof e?e.toString()+"n":"string"==typeof e?`"${e}"`:`${e}`}function eN(e,t=0){if(!0===e.aborted)return!0;for(let i=t;i<e.issues.length;i++)if(e.issues[i]?.continue!==!0)return!0;return!1}function eV(e,t){return t.map(t=>(t.path??(t.path=[]),t.path.unshift(e),t))}function eD(e){return"string"==typeof e?e:e?.message}function eZ(e,t,i){let n={...e,path:e.path??[]};return e.message||(n.message=eD(e.inst?._zod.def?.error?.(e))??eD(t?.error?.(e))??eD(i.customError?.(e))??eD(i.localeError?.(e))??"Invalid input"),delete n.inst,delete n.continue,t?.reportInput||delete n.input,n}function eQ(e){return Array.isArray(e)?"array":"string"==typeof e?"string":"unknown"}let eL=(e,t)=>{e.name="$ZodError",Object.defineProperty(e,"_zod",{value:e._zod,enumerable:!1}),Object.defineProperty(e,"issues",{value:t,enumerable:!1}),e.message=JSON.stringify(t,ex,2),Object.defineProperty(e,"toString",{value:()=>e.message,enumerable:!1})},eJ=e_("$ZodError",eL),eH=e_("$ZodError",eL,{Parent:Error}),eK=(e=eH,(t,i,n,r)=>{let s=n?Object.assign(n,{async:!1}):{async:!1},o=t._zod.run({value:i,issues:[]},s);if(o instanceof Promise)throw new ez;if(o.issues.length){let t=new(r?.Err??e)(o.issues.map(e=>eZ(e,s,eS())));throw eT(t,r?.callee),t}return o.value}),eW=(t=eH,async(e,i,n,r)=>{let s=n?Object.assign(n,{async:!0}):{async:!0},o=e._zod.run({value:i,issues:[]},s);if(o instanceof Promise&&(o=await o),o.issues.length){let e=new(r?.Err??t)(o.issues.map(e=>eZ(e,s,eS())));throw eT(e,r?.callee),e}return o.value}),eG=(i=eH,(e,t,n)=>{let r=n?{...n,async:!1}:{async:!1},s=e._zod.run({value:t,issues:[]},r);if(s instanceof Promise)throw new ez;return s.issues.length?{success:!1,error:new(i??eJ)(s.issues.map(e=>eZ(e,r,eS())))}:{success:!0,data:s.value}}),eX=(n=eH,async(e,t,i)=>{let r=i?Object.assign(i,{async:!0}):{async:!0},s=e._zod.run({value:t,issues:[]},r);return s instanceof Promise&&(s=await s),s.issues.length?{success:!1,error:new n(s.issues.map(e=>eZ(e,r,eS())))}:{success:!0,data:s.value}}),eY=/^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/,e0="(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))",e1=RegExp(`^${e0}$`);function e2(e){let t="(?:[01]\\d|2[0-3]):[0-5]\\d";return"number"==typeof e.precision?-1===e.precision?`${t}`:0===e.precision?`${t}:[0-5]\\d`:`${t}:[0-5]\\d\\.\\d{${e.precision}}`:`${t}(?::[0-5]\\d(?:\\.\\d+)?)?`}let e6=/^-?\d+(?:\.\d+)?$/,e3=/^(?:true|false)$/i,e4=/^null$/i,e8=e_("$ZodCheck",(e,t)=>{var i;e._zod??(e._zod={}),e._zod.def=t,(i=e._zod).onattach??(i.onattach=[])}),e5=e_("$ZodCheckMinLength",(e,t)=>{var i;e8.init(e,t),(i=e._zod.def).when??(i.when=e=>{let t=e.value;return null!=t&&void 0!==t.length}),e._zod.onattach.push(e=>{let i=e._zod.bag.minimum??-1/0;t.minimum>i&&(e._zod.bag.minimum=t.minimum)}),e._zod.check=i=>{let n=i.value;if(n.length>=t.minimum)return;let r=eQ(n);i.issues.push({origin:r,code:"too_small",minimum:t.minimum,inclusive:!0,input:n,inst:e,continue:!t.abort})}}),e9=e_("$ZodCheckLengthEquals",(e,t)=>{var i;e8.init(e,t),(i=e._zod.def).when??(i.when=e=>{let t=e.value;return null!=t&&void 0!==t.length}),e._zod.onattach.push(e=>{let i=e._zod.bag;i.minimum=t.length,i.maximum=t.length,i.length=t.length}),e._zod.check=i=>{let n=i.value,r=n.length;if(r===t.length)return;let s=eQ(n),o=r>t.length;i.issues.push({origin:s,...o?{code:"too_big",maximum:t.length}:{code:"too_small",minimum:t.length},inclusive:!0,exact:!0,input:i.value,inst:e,continue:!t.abort})}}),e7=e_("$ZodCheckStringFormat",(e,t)=>{var i,n;e8.init(e,t),e._zod.onattach.push(e=>{let i=e._zod.bag;i.format=t.format,t.pattern&&(i.patterns??(i.patterns=new Set),i.patterns.add(t.pattern))}),t.pattern?(i=e._zod).check??(i.check=i=>{t.pattern.lastIndex=0,t.pattern.test(i.value)||i.issues.push({origin:"string",code:"invalid_format",format:t.format,input:i.value,...t.pattern?{pattern:t.pattern.toString()}:{},inst:e,continue:!t.abort})}):(n=e._zod).check??(n.check=()=>{})}),te={major:4,minor:3,patch:6},tt=e_("$ZodType",(e,t)=>{var i;e??(e={}),e._zod.def=t,e._zod.bag=e._zod.bag||{},e._zod.version=te;let n=[...e._zod.def.checks??[]];for(let t of(e._zod.traits.has("$ZodCheck")&&n.unshift(e),n))for(let i of t._zod.onattach)i(e);if(0===n.length)(i=e._zod).deferred??(i.deferred=[]),e._zod.deferred?.push(()=>{e._zod.run=e._zod.parse});else{let t=(e,t,i)=>{let n,r=eN(e);for(let s of t){if(s._zod.def.when){if(!s._zod.def.when(e))continue}else if(r)continue;let t=e.issues.length,o=s._zod.check(e);if(o instanceof Promise&&i?.async===!1)throw new ez;if(n||o instanceof Promise)n=(n??Promise.resolve()).then(async()=>{await o,e.issues.length!==t&&(r||(r=eN(e,t)))});else{if(e.issues.length===t)continue;r||(r=eN(e,t))}}return n?n.then(()=>e):e},i=(i,r,s)=>{if(eN(i))return i.aborted=!0,i;let o=t(r,n,s);if(o instanceof Promise){if(!1===s.async)throw new ez;return o.then(t=>e._zod.parse(t,s))}return e._zod.parse(o,s)};e._zod.run=(r,s)=>{if(s.skipChecks)return e._zod.parse(r,s);if("backward"===s.direction){let t=e._zod.parse({value:r.value,issues:[]},{...s,skipChecks:!0});return t instanceof Promise?t.then(e=>i(e,r,s)):i(t,r,s)}let o=e._zod.parse(r,s);if(o instanceof Promise){if(!1===s.async)throw new ez;return o.then(e=>t(e,n,s))}return t(o,n,s)}}eP(e,"~standard",()=>({validate:t=>{try{let i=eG(e,t);return i.success?{value:i.data}:{issues:i.error?.issues}}catch(i){return eX(e,t).then(e=>e.success?{value:e.data}:{issues:e.error?.issues})}},vendor:"zod",version:1}))}),ti=e_("$ZodString",(e,t)=>{var i;let n;tt.init(e,t),e._zod.pattern=[...e?._zod.bag?.patterns??[]].pop()??(n=(i=e._zod.bag)?`[\\s\\S]{${i?.minimum??0},${i?.maximum??""}}`:"[\\s\\S]*",RegExp(`^${n}$`)),e._zod.parse=(i,n)=>{if(t.coerce)try{i.value=String(i.value)}catch(e){}return"string"==typeof i.value||i.issues.push({expected:"string",code:"invalid_type",input:i.value,inst:e}),i}}),tn=e_("$ZodStringFormat",(e,t)=>{e7.init(e,t),ti.init(e,t)}),tr=e_("$ZodISODateTime",(e,t)=>{let i,n,r;t.pattern??(i=e2({precision:t.precision}),n=["Z"],t.local&&n.push(""),t.offset&&n.push("([+-](?:[01]\\d|2[0-3]):[0-5]\\d)"),r=`${i}(?:${n.join("|")})`,t.pattern=RegExp(`^${e0}T(?:${r})$`)),tn.init(e,t)}),ts=((e,t)=>{t.pattern??(t.pattern=e1),tn.init(e,t)},e_("$ZodNumber",(e,t)=>{tt.init(e,t),e._zod.pattern=e._zod.bag.pattern??e6,e._zod.parse=(i,n)=>{if(t.coerce)try{i.value=Number(i.value)}catch(e){}let r=i.value;if("number"==typeof r&&!Number.isNaN(r)&&Number.isFinite(r))return i;let s="number"==typeof r?Number.isNaN(r)?"NaN":Number.isFinite(r)?void 0:"Infinity":void 0;return i.issues.push({expected:"number",code:"invalid_type",input:r,inst:e,...s?{received:s}:{}}),i}})),to=e_("$ZodBoolean",(e,t)=>{tt.init(e,t),e._zod.pattern=e3,e._zod.parse=(i,n)=>{if(t.coerce)try{i.value=!!i.value}catch(e){}let r=i.value;return"boolean"==typeof r||i.issues.push({expected:"boolean",code:"invalid_type",input:r,inst:e}),i}}),ta=e_("$ZodNull",(e,t)=>{tt.init(e,t),e._zod.pattern=e4,e._zod.values=new Set([null]),e._zod.parse=(t,i)=>{let n=t.value;return null===n||t.issues.push({expected:"null",code:"invalid_type",input:n,inst:e}),t}}),tl=e_("$ZodAny",(e,t)=>{tt.init(e,t),e._zod.parse=e=>e}),tu=e_("$ZodUnknown",(e,t)=>{tt.init(e,t),e._zod.parse=e=>e});function tc(e,t,i){e.issues.length&&t.issues.push(...eV(i,e.issues)),t.value[i]=e.value}let td=e_("$ZodArray",(e,t)=>{tt.init(e,t),e._zod.parse=(i,n)=>{let r=i.value;if(!Array.isArray(r))return i.issues.push({expected:"array",code:"invalid_type",input:r,inst:e}),i;i.value=Array(r.length);let s=[];for(let e=0;e<r.length;e++){let o=r[e],a=t.element._zod.run({value:o,issues:[]},n);a instanceof Promise?s.push(a.then(t=>tc(t,i,e))):tc(a,i,e)}return s.length?Promise.all(s).then(()=>i):i}});function tp(e,t,i,n,r){if(e.issues.length){if(r&&!(i in n))return;t.issues.push(...eV(i,e.issues))}void 0===e.value?i in n&&(t.value[i]=void 0):t.value[i]=e.value}let th=e_("$ZodObject",(e,t)=>{let i;tt.init(e,t);let n=Object.getOwnPropertyDescriptor(t,"shape");if(!n?.get){let e=t.shape;Object.defineProperty(t,"shape",{get:()=>{let i={...e};return Object.defineProperty(t,"shape",{value:i}),i}})}let r=ek(()=>(function(e){var t;let i=Object.keys(e.shape);for(let t of i)if(!e.shape?.[t]?._zod?.traits?.has("$ZodType"))throw Error(`Invalid element at key "${t}": expected a Zod schema`);let n=Object.keys(t=e.shape).filter(e=>"optional"===t[e]._zod.optin&&"optional"===t[e]._zod.optout);return{...e,keys:i,keySet:new Set(i),numKeys:i.length,optionalKeys:new Set(n)}})(t));eP(e._zod,"propValues",()=>{let e=t.shape,i={};for(let t in e){let n=e[t]._zod;if(n.values)for(let e of(i[t]??(i[t]=new Set),n.values))i[t].add(e)}return i});let s=t.catchall;e._zod.parse=(t,n)=>{i??(i=r.value);let o=t.value;if(!eF(o))return t.issues.push({expected:"object",code:"invalid_type",input:o,inst:e}),t;t.value={};let a=[],l=i.shape;for(let e of i.keys){let i=l[e],r="optional"===i._zod.optout,s=i._zod.run({value:o[e],issues:[]},n);s instanceof Promise?a.push(s.then(i=>tp(i,t,e,o,r))):tp(s,t,e,o,r)}return s?function(e,t,i,n,r,s){let o=[],a=r.keySet,l=r.catchall._zod,u=l.def.type,c="optional"===l.optout;for(let r in t){if(a.has(r))continue;if("never"===u){o.push(r);continue}let s=l.run({value:t[r],issues:[]},n);s instanceof Promise?e.push(s.then(e=>tp(e,i,r,t,c))):tp(s,i,r,t,c)}return(o.length&&i.issues.push({code:"unrecognized_keys",keys:o,input:t,inst:s}),e.length)?Promise.all(e).then(()=>i):i}(a,o,t,n,r.value,e):a.length?Promise.all(a).then(()=>t):t}});function tf(e,t,i,n){for(let i of e)if(0===i.issues.length)return t.value=i.value,t;let r=e.filter(e=>!eN(e));return 1===r.length?(t.value=r[0].value,r[0]):(t.issues.push({code:"invalid_union",input:t.value,inst:i,errors:e.map(e=>e.issues.map(e=>eZ(e,n,eS())))}),t)}let tv=e_("$ZodUnion",(e,t)=>{tt.init(e,t),eP(e._zod,"optin",()=>t.options.some(e=>"optional"===e._zod.optin)?"optional":void 0),eP(e._zod,"optout",()=>t.options.some(e=>"optional"===e._zod.optout)?"optional":void 0),eP(e._zod,"values",()=>{if(t.options.every(e=>e._zod.values))return new Set(t.options.flatMap(e=>Array.from(e._zod.values)))}),eP(e._zod,"pattern",()=>{if(t.options.every(e=>e._zod.pattern)){let e=t.options.map(e=>e._zod.pattern);return RegExp(`^(${e.map(e=>eI(e.source)).join("|")})$`)}});let i=1===t.options.length,n=t.options[0]._zod.run;e._zod.parse=(r,s)=>{if(i)return n(r,s);let o=!1,a=[];for(let e of t.options){let t=e._zod.run({value:r.value,issues:[]},s);if(t instanceof Promise)a.push(t),o=!0;else{if(0===t.issues.length)return t;a.push(t)}}return o?Promise.all(a).then(t=>tf(t,r,e,s)):tf(a,r,e,s)}}),ty=e_("$ZodDiscriminatedUnion",(e,t)=>{t.inclusive=!1,tv.init(e,t);let i=e._zod.parse;eP(e._zod,"propValues",()=>{let e={};for(let i of t.options){let n=i._zod.propValues;if(!n||0===Object.keys(n).length)throw Error(`Invalid discriminated union option at index "${t.options.indexOf(i)}"`);for(let[t,i]of Object.entries(n))for(let n of(e[t]||(e[t]=new Set),i))e[t].add(n)}return e});let n=ek(()=>{let e=t.options,i=new Map;for(let n of e){let e=n._zod.propValues?.[t.discriminator];if(!e||0===e.size)throw Error(`Invalid discriminated union option at index "${t.options.indexOf(n)}"`);for(let t of e){if(i.has(t))throw Error(`Duplicate discriminator value "${String(t)}"`);i.set(t,n)}}return i});e._zod.parse=(r,s)=>{let o=r.value;if(!eF(o))return r.issues.push({code:"invalid_type",expected:"object",input:o,inst:e}),r;let a=n.value.get(o?.[t.discriminator]);return a?a._zod.run(r,s):t.unionFallback?i(r,s):(r.issues.push({code:"invalid_union",errors:[],note:"No matching discriminator",discriminator:t.discriminator,input:o,path:[t.discriminator],inst:e}),r)}}),tg=e_("$ZodRecord",(e,t)=>{tt.init(e,t),e._zod.parse=(i,n)=>{let r=i.value;if(!eC(r))return i.issues.push({expected:"record",code:"invalid_type",input:r,inst:e}),i;let s=[],o=t.keyType._zod.values;if(o){let a;i.value={};let l=new Set;for(let e of o)if("string"==typeof e||"number"==typeof e||"symbol"==typeof e){l.add("number"==typeof e?e.toString():e);let o=t.valueType._zod.run({value:r[e],issues:[]},n);o instanceof Promise?s.push(o.then(t=>{t.issues.length&&i.issues.push(...eV(e,t.issues)),i.value[e]=t.value})):(o.issues.length&&i.issues.push(...eV(e,o.issues)),i.value[e]=o.value)}for(let e in r)l.has(e)||(a=a??[]).push(e);a&&a.length>0&&i.issues.push({code:"unrecognized_keys",input:r,inst:e,keys:a})}else for(let o of(i.value={},Reflect.ownKeys(r))){if("__proto__"===o)continue;let a=t.keyType._zod.run({value:o,issues:[]},n);if(a instanceof Promise)throw Error("Async schemas not supported in object keys currently");if("string"==typeof o&&e6.test(o)&&a.issues.length){let e=t.keyType._zod.run({value:Number(o),issues:[]},n);if(e instanceof Promise)throw Error("Async schemas not supported in object keys currently");0===e.issues.length&&(a=e)}if(a.issues.length){"loose"===t.mode?i.value[o]=r[o]:i.issues.push({code:"invalid_key",origin:"record",issues:a.issues.map(e=>eZ(e,n,eS())),input:o,path:[o],inst:e});continue}let l=t.valueType._zod.run({value:r[o],issues:[]},n);l instanceof Promise?s.push(l.then(e=>{e.issues.length&&i.issues.push(...eV(o,e.issues)),i.value[a.value]=e.value})):(l.issues.length&&i.issues.push(...eV(o,l.issues)),i.value[a.value]=l.value)}return s.length?Promise.all(s).then(()=>i):i}}),tm=e_("$ZodEnum",(e,t)=>{var i;let n;tt.init(e,t);let r=(n=Object.values(i=t.entries).filter(e=>"number"==typeof e),Object.entries(i).filter(([e,t])=>-1===n.indexOf(+e)).map(([e,t])=>t)),s=new Set(r);e._zod.values=s,e._zod.pattern=RegExp(`^(${r.filter(e=>eR.has(typeof e)).map(e=>"string"==typeof e?eM(e):e.toString()).join("|")})$`),e._zod.parse=(t,i)=>{let n=t.value;return s.has(n)||t.issues.push({code:"invalid_value",values:r,input:n,inst:e}),t}}),tb=e_("$ZodLiteral",(e,t)=>{if(tt.init(e,t),0===t.values.length)throw Error("Cannot create literal schema with no valid values");let i=new Set(t.values);e._zod.values=i,e._zod.pattern=RegExp(`^(${t.values.map(e=>"string"==typeof e?eM(e):e?eM(e.toString()):String(e)).join("|")})$`),e._zod.parse=(n,r)=>{let s=n.value;return i.has(s)||n.issues.push({code:"invalid_value",values:t.values,input:s,inst:e}),n}});function tw(e,t){return e.issues.length&&void 0===t?{issues:[],value:void 0}:e}let t_=e_("$ZodOptional",(e,t)=>{tt.init(e,t),e._zod.optin="optional",e._zod.optout="optional",eP(e._zod,"values",()=>t.innerType._zod.values?new Set([...t.innerType._zod.values,void 0]):void 0),eP(e._zod,"pattern",()=>{let e=t.innerType._zod.pattern;return e?RegExp(`^(${eI(e.source)})?$`):void 0}),e._zod.parse=(e,i)=>{if("optional"===t.innerType._zod.optin){let n=t.innerType._zod.run(e,i);return n instanceof Promise?n.then(t=>tw(t,e.value)):tw(n,e.value)}return void 0===e.value?e:t.innerType._zod.run(e,i)}}),tz=e_("$ZodNullable",(e,t)=>{tt.init(e,t),eP(e._zod,"optin",()=>t.innerType._zod.optin),eP(e._zod,"optout",()=>t.innerType._zod.optout),eP(e._zod,"pattern",()=>{let e=t.innerType._zod.pattern;return e?RegExp(`^(${eI(e.source)}|null)$`):void 0}),eP(e._zod,"values",()=>t.innerType._zod.values?new Set([...t.innerType._zod.values,null]):void 0),e._zod.parse=(e,i)=>null===e.value?e:t.innerType._zod.run(e,i)}),tO=e_("$ZodPrefault",(e,t)=>{tt.init(e,t),e._zod.optin="optional",eP(e._zod,"values",()=>t.innerType._zod.values),e._zod.parse=(e,i)=>("backward"===i.direction||void 0===e.value&&(e.value=t.defaultValue),t.innerType._zod.run(e,i))}),tS=e_("$ZodLazy",(e,t)=>{tt.init(e,t),eP(e._zod,"innerType",()=>t.getter()),eP(e._zod,"pattern",()=>e._zod.innerType?._zod?.pattern),eP(e._zod,"propValues",()=>e._zod.innerType?._zod?.propValues),eP(e._zod,"optin",()=>e._zod.innerType?._zod?.optin??void 0),eP(e._zod,"optout",()=>e._zod.innerType?._zod?.optout??void 0),e._zod.parse=(t,i)=>e._zod.innerType._zod.run(t,i)});Symbol("ZodOutput"),Symbol("ZodInput");function tE(e,t){return new e5({check:"min_length",...eq(t),minimum:e})}(a=globalThis).__zod_globalRegistry??(a.__zod_globalRegistry=new class e{constructor(){this._map=new WeakMap,this._idmap=new Map}add(e,...t){let i=t[0];return this._map.set(e,i),i&&"object"==typeof i&&"id"in i&&this._idmap.set(i.id,e),this}clear(){return this._map=new WeakMap,this._idmap=new Map,this}remove(e){let t=this._map.get(e);return t&&"object"==typeof t&&"id"in t&&this._idmap.delete(t.id),this._map.delete(e),this}get(e){let t=e._zod.parent;if(t){let i={...this.get(t)??{}};delete i.id;let n={...i,...this._map.get(e)};return Object.keys(n).length?n:void 0}return this._map.get(e)}has(e){return this._map.has(e)}});let tx=e_("ZodMiniType",(e,t)=>{if(!e._zod)throw Error("Uninitialized schema in ZodMiniType.");tt.init(e,t),e.def=t,e.type=t.type,e.parse=(t,i)=>eK(e,t,i,{callee:e.parse}),e.safeParse=(t,i)=>eG(e,t,i),e.parseAsync=async(t,i)=>eW(e,t,i,{callee:e.parseAsync}),e.safeParseAsync=async(t,i)=>eX(e,t,i),e.check=(...i)=>e.clone({...t,checks:[...t.checks??[],...i.map(e=>"function"==typeof e?{_zod:{check:e,def:{check:"custom"},onattach:[]}}:e)]},{parent:!0}),e.with=e.check,e.clone=(t,i)=>eB(e,t,i),e.brand=()=>e,e.register=(t,i)=>(t.add(e,i),e),e.apply=t=>t(e)}),tk=e_("ZodMiniString",(e,t)=>{ti.init(e,t),tx.init(e,t)});function tI(e){return new tk({type:"string",...eq(e)})}let t$=e_("ZodMiniStringFormat",(e,t)=>{tn.init(e,t),tk.init(e,t)}),tP=e_("ZodMiniNumber",(e,t)=>{ts.init(e,t),tx.init(e,t)});function tj(e){return new tP({type:"number",checks:[],...eq(e)})}let tA=e_("ZodMiniBoolean",(e,t)=>{to.init(e,t),tx.init(e,t)});function tT(e){return new tA({type:"boolean",...eq(e)})}let tF=e_("ZodMiniNull",(e,t)=>{ta.init(e,t),tx.init(e,t)});function tC(e){return new tF({type:"null",...eq(e)})}let tR=e_("ZodMiniAny",(e,t)=>{tl.init(e,t),tx.init(e,t)});function tM(){return new tR({type:"any"})}let tB=e_("ZodMiniUnknown",(e,t)=>{tu.init(e,t),tx.init(e,t)}),tq=e_("ZodMiniArray",(e,t)=>{td.init(e,t),tx.init(e,t)});function tU(e,t){return new tq({type:"array",element:e,...eq(t)})}let tN=e_("ZodMiniObject",(e,t)=>{th.init(e,t),tx.init(e,t),eP(e,"shape",()=>t.shape)});function tV(e,t){return new tN({type:"object",shape:e??{},...eq(t)})}function tD(e,t){if(!eC(t))throw Error("Invalid input to extend: expected a plain object");let i=e._zod.def.checks;if(i&&i.length>0){let i=e._zod.def.shape;for(let e in t)if(void 0!==Object.getOwnPropertyDescriptor(i,e))throw Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.")}let n=eA(e._zod.def,{get shape(){let i={...e._zod.def.shape,...t};return ej(this,"shape",i),i}});return eB(e,n)}function tZ(e,t){return e.clone({...e._zod.def,catchall:t})}let tQ=e_("ZodMiniUnion",(e,t)=>{tv.init(e,t),tx.init(e,t)});function tL(e,t){return new tQ({type:"union",options:e,...eq(t)})}let tJ=e_("ZodMiniDiscriminatedUnion",(e,t)=>{ty.init(e,t),tx.init(e,t)});function tH(e,t,i){return new tJ({type:"union",options:t,discriminator:e,...eq(i)})}let tK=e_("ZodMiniRecord",(e,t)=>{tg.init(e,t),tx.init(e,t)});function tW(e,t,i){return new tK({type:"record",keyType:e,valueType:t,...eq(i)})}let tG=e_("ZodMiniEnum",(e,t)=>{tm.init(e,t),tx.init(e,t),e.options=Object.values(t.entries)});function tX(e,t){return new tG({type:"enum",entries:Array.isArray(e)?Object.fromEntries(e.map(e=>[e,e])):e,...eq(t)})}let tY=e_("ZodMiniLiteral",(e,t)=>{tb.init(e,t),tx.init(e,t)});function t0(e,t){return new tY({type:"literal",values:Array.isArray(e)?e:[e],...eq(t)})}let t1=e_("ZodMiniOptional",(e,t)=>{t_.init(e,t),tx.init(e,t)});function t2(e){return new t1({type:"optional",innerType:e})}let t6=e_("ZodMiniNullable",(e,t)=>{tz.init(e,t),tx.init(e,t)});function t3(e){return new t6({type:"nullable",innerType:e})}let t4=e_("ZodMiniPrefault",(e,t)=>{tO.init(e,t),tx.init(e,t)});function t8(e,t){return new t4({type:"prefault",innerType:e,get defaultValue(){return"function"==typeof t?t():eC(t)?{...t}:Array.isArray(t)?[...t]:t}})}let t5=e_("ZodMiniLazy",(e,t)=>{tS.init(e,t),tx.init(e,t)});function t9(){let e=new t5({type:"lazy",getter:()=>tL([tI(),tj(),tT(),tC(),tU(e),tW(tI(),e)])});return e}let t7=e_("ZodMiniISODateTime",(e,t)=>{tr.init(e,t),t$.init(e,t)});function ie(e){return new t7({type:"string",format:"datetime",check:"string_format",offset:!1,local:!1,precision:null,...eq(e)})}let it=tZ(tV({}),t9()),ii=tV({sys:tV({type:t0("Link"),linkType:tI(),id:tI()})}),ir=tV({sys:tV({type:t0("Link"),linkType:t0("ContentType"),id:tI()})}),is=tV({sys:tV({type:t0("Link"),linkType:t0("Environment"),id:tI()})}),io=tV({sys:tV({type:t0("Link"),linkType:t0("Space"),id:tI()})}),ia=tV({sys:tV({type:t0("Link"),linkType:t0("TaxonomyConcept"),id:tI()})}),il=tV({sys:tV({type:t0("Link"),linkType:t0("Tag"),id:tI()})}),iu=tV({type:t0("Entry"),contentType:ir,publishedVersion:tj(),id:tI(),createdAt:tM(),updatedAt:tM(),locale:t2(tI()),revision:tj(),space:io,environment:is}),ic=tV({fields:it,metadata:tV({tags:tU(il),concepts:t2(tU(ia))}),sys:iu}),id=tD(it,{nt_audience_id:tI(),nt_name:t2(tI()),nt_description:t2(tI())}),ip=tD(ic,{fields:id});tV({contentTypeId:t0("nt_audience"),fields:id});let ih=tD(ic,{fields:tV({nt_name:tI(),nt_fallback:t2(tI()),nt_mergetag_id:tI()}),sys:tD(iu,{contentType:tV({sys:tV({type:t0("Link"),linkType:t0("ContentType"),id:t0("nt_mergetag")})})})}),iv=tV({id:tI(),hidden:t2(tT())}),iy=tV({type:t2(t0("EntryReplacement")),baseline:iv,variants:tU(iv)}),ig=tV({value:tL([tI(),tT(),tC(),tj(),tW(tI(),t9())])}),im=tX(["Boolean","Number","Object","String"]),ib=tH("type",[iy,tV({type:t0("InlineVariable"),key:tI(),valueType:im,baseline:ig,variants:tU(ig)})]),iw=tU(ib),i_=tV({distribution:t2(tU(tj())),traffic:t2(tj()),components:t2(iw),sticky:t2(tT())}),iz=tL([t0("nt_experiment"),t0("nt_personalization")]),iO=tD(it,{nt_name:tI(),nt_description:t2(t3(tI())),nt_type:iz,nt_config:t2(t3(i_)),nt_audience:t2(t3(ip)),nt_variants:t2(tU(tL([ii,ic]))),nt_experience_id:tI()}),iS=tD(ic,{fields:iO});tV({contentTypeId:t0("nt_experience"),fields:iO});let iE=tD(ic,{fields:tD(it,{nt_experiences:tU(tL([ii,iS]))})});function ix(e){return iS.safeParse(e).success}function ik(e){return iE.safeParse(e).success}let iI=t2(tV({name:tI(),version:tI()})),i$=tV({name:t2(tI()),source:t2(tI()),medium:t2(tI()),term:t2(tI()),content:t2(tI())}),iP=tL([t0("mobile"),t0("server"),t0("web")]),ij=tW(tI(),tI()),iA=tV({latitude:tj(),longitude:tj()}),iT=tV({coordinates:t2(iA),city:t2(tI()),postalCode:t2(tI()),region:t2(tI()),regionCode:t2(tI()),country:t2(tI()),countryCode:t2(tI().check(new e9({check:"length_equals",...eq(void 0),length:2}))),continent:t2(tI()),timezone:t2(tI())}),iF=tV({name:tI(),version:tI()}),iC=tZ(tV({path:tI(),query:ij,referrer:tI(),search:tI(),title:t2(tI()),url:tI()}),t9()),iR=tW(tI(),t9()),iM=tZ(tV({name:tI()}),t9()),iB=tW(tI(),t9()),iq=tV({app:iI,campaign:i$,gdpr:tV({isConsentGiven:tT()}),library:iF,locale:tI(),location:t2(iT),userAgent:t2(tI())}),iU=tV({channel:iP,context:tD(iq,{page:t2(iC),screen:t2(iM)}),messageId:tI(),originalTimestamp:ie(),sentAt:ie(),timestamp:ie(),userId:t2(tI())}),iN=tD(iU,{type:t0("alias")}),iV=tD(iU,{type:t0("group")}),iD=tD(iU,{type:t0("identify"),traits:iB}),iZ=tD(iq,{page:iC}),iQ=tD(iU,{type:t0("page"),name:t2(tI()),properties:iC,context:iZ}),iL=tD(iq,{screen:iM}),iJ=tD(iU,{type:t0("screen"),name:tI(),properties:t2(iR),context:iL}),iH=tD(iU,{type:t0("track"),event:tI(),properties:iR}),iK=tD(iU,{componentType:tL([t0("Entry"),t0("Variable")]),componentId:tI(),experienceId:t2(tI()),variantIndex:tj()}),iW=tD(iK,{type:t0("component"),viewDurationMs:t2(tj()),viewId:t2(tI())}),iG={anonymousId:tI()},iX=tU(tH("type",[tD(iN,iG),tD(iW,iG),tD(iV,iG),tD(iD,iG),tD(iQ,iG),tD(iJ,iG),tD(iH,iG)])),iY=tH("type",[iN,iW,iV,iD,iQ,iJ,iH]),i0=tU(iY),i1=tV({features:t2(tU(tI()))}),i2=tV({events:i0.check(tE(1)),options:t2(i1)}),i6=tV({events:iX.check(tE(1)),options:t2(i1)}),i3=tV({id:tI(),isReturningVisitor:tT(),landingPage:iC,count:tj(),activeSessionLength:tj(),averageSessionLength:tj()}),i4=tV({id:tI(),stableId:tI(),random:tj(),audiences:tU(tI()),traits:iB,location:iT,session:i3}),i8=tZ(tV({id:tI()}),t9()),i5=tV({data:tV(),message:tI(),error:t3(tT())}),i9=tD(i5,{data:tV({profiles:t2(tU(i4))})}),i7=tV({key:tI(),type:tL([tX(["Variable"]),tI()]),meta:tV({experienceId:tI(),variantIndex:tj()})}),ne=tL([tI(),tT(),tC(),tj(),tW(tI(),t9())]);tD(i7,{type:tI(),value:new tB({type:"unknown"})});let nt=tU(tH("type",[tD(i7,{type:t0("Variable"),value:ne})])),ni=tU(tV({experienceId:tI(),variantIndex:tj(),variants:tW(tI(),tI()),sticky:t2(t8(tT(),!1))})),nn=tD(i5,{data:tV({profile:i4,experiences:ni,changes:nt})}),nr=tH("type",[iW,tD(iK,{type:t0("component_click")}),tD(iK,{type:t0("component_hover"),hoverDurationMs:tj(),hoverId:tI()})]),ns=tV({profile:i8,events:tU(nr)}),no=tU(ns);function na(e,t){let i=e.safeParse(t);if(i.success)return i.data;throw Error(function(e){let t=[];for(let i of[...e.issues].sort((e,t)=>(e.path??[]).length-(t.path??[]).length))t.push(`✖ ${i.message}`),i.path?.length&&t.push(`  → at ${function(e){let t=[];for(let i of e.map(e=>"object"==typeof e?e.key:e))"number"==typeof i?t.push(`[${i}]`):"symbol"==typeof i?t.push(`[${JSON.stringify(String(i))}]`):/[^\w$]/.test(i)?t.push(`[${JSON.stringify(i)}]`):(t.length&&t.push("."),t.push(i));return t.join("")}(i.path)}`);return t.join("\n")}(i.error))}eS({localeError:(r={string:{unit:"characters",verb:"to have"},file:{unit:"bytes",verb:"to have"},array:{unit:"items",verb:"to have"},set:{unit:"items",verb:"to have"},map:{unit:"entries",verb:"to have"}},s={regex:"input",email:"email address",url:"URL",emoji:"emoji",uuid:"UUID",uuidv4:"UUIDv4",uuidv6:"UUIDv6",nanoid:"nanoid",guid:"GUID",cuid:"cuid",cuid2:"cuid2",ulid:"ULID",xid:"XID",ksuid:"KSUID",datetime:"ISO datetime",date:"ISO date",time:"ISO time",duration:"ISO duration",ipv4:"IPv4 address",ipv6:"IPv6 address",mac:"MAC address",cidrv4:"IPv4 range",cidrv6:"IPv6 range",base64:"base64-encoded string",base64url:"base64url-encoded string",json_string:"JSON string",e164:"E.164 number",jwt:"JWT",template_literal:"input"},o={nan:"NaN"},e=>{switch(e.code){case"invalid_type":{let t=o[e.expected]??e.expected,i=function(e){let t=typeof e;switch(t){case"number":return Number.isNaN(e)?"nan":"number";case"object":if(null===e)return"null";if(Array.isArray(e))return"array";if(e&&Object.getPrototypeOf(e)!==Object.prototype&&"constructor"in e&&e.constructor)return e.constructor.name}return t}(e.input),n=o[i]??i;return`Invalid input: expected ${t}, received ${n}`}case"invalid_value":if(1===e.values.length)return`Invalid input: expected ${eU(e.values[0])}`;return`Invalid option: expected one of ${eE(e.values,"|")}`;case"too_big":{let t=e.inclusive?"<=":"<",i=r[e.origin]??null;if(i)return`Too big: expected ${e.origin??"value"} to have ${t}${e.maximum.toString()} ${i.unit??"elements"}`;return`Too big: expected ${e.origin??"value"} to be ${t}${e.maximum.toString()}`}case"too_small":{let t=e.inclusive?">=":">",i=r[e.origin]??null;if(i)return`Too small: expected ${e.origin} to have ${t}${e.minimum.toString()} ${i.unit}`;return`Too small: expected ${e.origin} to be ${t}${e.minimum.toString()}`}case"invalid_format":if("starts_with"===e.format)return`Invalid string: must start with "${e.prefix}"`;if("ends_with"===e.format)return`Invalid string: must end with "${e.suffix}"`;if("includes"===e.format)return`Invalid string: must include "${e.includes}"`;if("regex"===e.format)return`Invalid string: must match pattern ${e.pattern}`;return`Invalid ${s[e.format]??e.format}`;case"not_multiple_of":return`Invalid number: must be a multiple of ${e.divisor}`;case"unrecognized_keys":return`Unrecognized key${e.keys.length>1?"s":""}: ${eE(e.keys,", ")}`;case"invalid_key":return`Invalid key in ${e.origin}`;case"invalid_union":default:return"Invalid input";case"invalid_element":return`Invalid value in ${e.origin}`}})});let nl=new class{name="@contentful/optimization";PREFIX_PARTS=["Ctfl","O10n"];DELIMITER=":";sinks=[];assembleLocationPrefix(e){return`[${[...this.PREFIX_PARTS,e].join(this.DELIMITER)}]`}addSink(e){this.sinks=[...this.sinks.filter(t=>t.name!==e.name),e]}removeSink(e){this.sinks=this.sinks.filter(t=>t.name!==e)}removeSinks(){this.sinks=[]}debug(e,t,...i){this.emit("debug",e,t,...i)}info(e,t,...i){this.emit("info",e,t,...i)}log(e,t,...i){this.emit("log",e,t,...i)}warn(e,t,...i){this.emit("warn",e,t,...i)}error(e,t,...i){this.emit("error",e,t,...i)}fatal(e,t,...i){this.emit("fatal",e,t,...i)}emit(e,t,i,...n){this.onLogEvent({name:this.name,level:e,messages:[`${this.assembleLocationPrefix(t)} ${String(i)}`,...n]})}onLogEvent(e){this.sinks.forEach(t=>{t.ingest(e)})}};function nu(e){return{debug:(t,...i)=>{nl.debug(e,t,...i)},info:(t,...i)=>{nl.info(e,t,...i)},log:(t,...i)=>{nl.log(e,t,...i)},warn:(t,...i)=>{nl.warn(e,t,...i)},error:(t,...i)=>{nl.error(e,t,...i)},fatal:(t,...i)=>{nl.fatal(e,t,...i)}}}let nc={fatal:60,error:50,warn:40,info:30,debug:20,log:10},nd=class{},np={debug:(...e)=>{console.debug(...e)},info:(...e)=>{console.info(...e)},log:(...e)=>{console.log(...e)},warn:(...e)=>{console.warn(...e)},error:(...e)=>{console.error(...e)},fatal:(...e)=>{console.error(...e)}};class nh extends nd{name="ConsoleLogSink";verbosity;constructor(e){super(),this.verbosity=e??"error"}ingest(e){nc[e.level]<nc[this.verbosity]||np[e.level](...e.messages)}}let nf=nu("ApiClient:Retry");class nv extends Error{status;constructor(e,t=500){super(e),Object.setPrototypeOf(this,nv.prototype),this.status=t}}async function ny(e){if(e<=0)return;let{promise:t,resolve:i}=Promise.withResolvers();setTimeout(()=>{i(void 0)},e),await t}let ng=nu("ApiClient:Timeout"),nm=nu("ApiClient:Fetch"),nb=function(e){try{let t=function({apiName:e="Optimization",fetchMethod:t=fetch,onRequestTimeout:i,requestTimeout:n=3e3}={}){return async(r,s)=>{let o=new AbortController,a=setTimeout(()=>{"function"==typeof i?i({apiName:e}):ng.error(`Request to "${r.toString()}" timed out`,Error("Request timeout")),o.abort()},n),l=await t(r,{...s,signal:o.signal});return clearTimeout(a),l}}(e);return function({apiName:e="Optimization",fetchMethod:t=fetch,intervalTimeout:i=0,onFailedAttempt:n,retries:r=1}={}){return async(s,o)=>{let a=new AbortController,l=r+1,u=function({apiName:e="Optimization",controller:t,fetchMethod:i=fetch,init:n,url:r}){return async()=>{try{let s=await i(r,n);if(503===s.status)throw new nv(`${e} API request to "${r.toString()}" failed with status: "[${s.status}] ${s.statusText}".`,503);if(!s.ok){let e=Error(`Request to "${r.toString()}" failed with status: [${s.status}] ${s.statusText} - traceparent: ${s.headers.get("traceparent")}`);nf.error("Request failed with non-OK status:",e),t.abort();return}return nf.debug(`Response from "${r.toString()}":`,s),s}catch(e){if(e instanceof nv&&503===e.status)throw e;nf.error(`Request to "${r.toString()}" failed:`,e),t.abort()}}}({apiName:e,controller:a,fetchMethod:t,init:o,url:s});for(let t=1;t<=l;t++)try{let e=await u();if(e)return e;break}catch(s){if(!(s instanceof nv)||503!==s.status)throw s;let r=l-t;if(n?.({apiName:e,error:s,attemptNumber:t,retriesLeft:r}),0===r)throw s;await ny(i)}throw Error(`${e} API request to "${s.toString()}" may not be retried.`)}}({...e,fetchMethod:t})}catch(e){throw e instanceof Error&&("AbortError"===e.name?nm.warn("Request aborted due to network issues. This request may not be retried."):nm.error("Request failed:",e)),e}},nw=nu("ApiClient"),n_=class{name;clientId;environment;fetch;constructor(e,{fetchOptions:t,clientId:i,environment:n}){this.clientId=i,this.environment=n??"main",this.name=e,this.fetch=nb({...t??{},apiName:e})}logRequestError(e,{requestName:t}){e instanceof Error&&("AbortError"===e.name?nw.warn(`[${this.name}] "${t}" request aborted due to network issues. This request may not be retried.`):nw.error(`[${this.name}] "${t}" request failed:`,e))}},nz=nu("ApiClient:Experience");class nO extends n_{baseUrl;enabledFeatures;ip;locale;plainText;preflight;constructor(e){super("Experience",e);const{baseUrl:t,enabledFeatures:i,ip:n,locale:r,plainText:s,preflight:o}=e;this.baseUrl=t||"https://experience.ninetailed.co/",this.enabledFeatures=i,this.ip=n,this.locale=r,this.plainText=s,this.preflight=o}async getProfile(e,t={}){if(!e)throw Error("Valid profile ID required.");let i="Get Profile";nz.info(`Sending "${i}" request`);try{let n=await this.fetch(this.constructUrl(`v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${e}`,t),{method:"GET"}),{data:{changes:r,experiences:s,profile:o}}=na(nn,await n.json());return nz.debug(`"${i}" request successfully completed`),{changes:r,selectedOptimizations:s,profile:o}}catch(e){throw this.logRequestError(e,{requestName:i}),e}}async makeProfileMutationRequest({url:e,body:t,options:i}){return await this.fetch(this.constructUrl(e,i),{method:"POST",headers:this.constructHeaders(i),body:JSON.stringify(t),keepalive:!0})}async createProfile({events:e},t={}){let i="Create Profile";nz.info(`Sending "${i}" request`);let n=this.constructExperienceRequestBody(e,t);nz.debug(`"${i}" request body:`,n);try{let e=await this.makeProfileMutationRequest({url:`v2/organizations/${this.clientId}/environments/${this.environment}/profiles`,body:n,options:t}),{data:{changes:r,experiences:s,profile:o}}=na(nn,await e.json());return nz.debug(`"${i}" request successfully completed`),{changes:r,selectedOptimizations:s,profile:o}}catch(e){throw this.logRequestError(e,{requestName:i}),e}}async updateProfile({profileId:e,events:t},i={}){if(!e)throw Error("Valid profile ID required.");let n="Update Profile";nz.info(`Sending "${n}" request`);let r=this.constructExperienceRequestBody(t,i);nz.debug(`"${n}" request body:`,r);try{let t=await this.makeProfileMutationRequest({url:`v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${e}`,body:r,options:i}),{data:{changes:s,experiences:o,profile:a}}=na(nn,await t.json());return nz.debug(`"${n}" request successfully completed`),{changes:s,selectedOptimizations:o,profile:a}}catch(e){throw this.logRequestError(e,{requestName:n}),e}}async upsertProfile({profileId:e,events:t},i){return e?await this.updateProfile({profileId:e,events:t},i):await this.createProfile({events:t},i)}async upsertManyProfiles({events:e},t={}){let i="Upsert Many Profiles";nz.info(`Sending "${i}" request`);let n=na(i6,{events:e,options:this.constructBodyOptions(t)});nz.debug(`"${i}" request body:`,n);try{let e=await this.makeProfileMutationRequest({url:`v2/organizations/${this.clientId}/environments/${this.environment}/events`,body:n,options:{plainText:!1,...t}}),{data:{profiles:r}}=na(i9,await e.json());return nz.debug(`"${i}" request successfully completed`),r}catch(e){throw this.logRequestError(e,{requestName:i}),e}}constructUrl(e,t){let i=new URL(e,this.baseUrl),n=t.locale??this.locale,r=t.preflight??this.preflight;return n&&i.searchParams.set("locale",n),r&&i.searchParams.set("type","preflight"),i.toString()}constructHeaders({ip:e=this.ip,plainText:t=this.plainText}){let i=new Map;return e&&i.set("X-Force-IP",e),t??this.plainText??!0?i.set("Content-Type","text/plain"):i.set("Content-Type","application/json"),Object.fromEntries(i)}constructBodyOptions=({enabledFeatures:e=this.enabledFeatures})=>{let t={};return e&&Array.isArray(e)&&e.length>0?t.features=e:t.features=["ip-enrichment","location"],t};constructExperienceRequestBody(e,t){return i2.parse({events:na(i0,e),options:this.constructBodyOptions(t)})}}let nS=nu("ApiClient:Insights");class nE extends n_{baseUrl;beaconHandler;constructor(e){super("Insights",e);const{baseUrl:t,beaconHandler:i}=e;this.baseUrl=t||"https://ingest.insights.ninetailed.co/",this.beaconHandler=i}async sendBatchEvents(e,t={}){let{beaconHandler:i=this.beaconHandler}=t,n=new URL(`v1/organizations/${this.clientId}/environments/${this.environment}/events`,this.baseUrl),r=na(no,e);if("function"==typeof i){if(nS.debug("Queueing events via beaconHandler"),i(n,r))return!0;nS.warn("beaconHandler failed to queue events; events will be emitted immediately via fetch")}let s="Event Batches";nS.info(`Sending "${s}" request`),nS.debug(`"${s}" request body:`,r);try{return await this.fetch(n,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(r),keepalive:!0}),nS.debug(`"${s}" request successfully completed`),!0}catch(e){return this.logRequestError(e,{requestName:s}),!1}}}class nx{config;experience;insights;constructor(e){const{experience:t,insights:i,clientId:n,environment:r,fetchOptions:s}=e,o={clientId:n,environment:r,fetchOptions:s};this.config=o,this.experience=new nO({...o,...t}),this.insights=new nE({...o,...i})}}function nk(e){if(!e||"object"!=typeof e)return!1;let t=Object.getPrototypeOf(e);return(null===t||t===Object.prototype||null===Object.getPrototypeOf(t))&&"[object Object]"===Object.prototype.toString.call(e)}function nI(e){return nk(e)||Array.isArray(e)}let n$=tV({campaign:t2(i$),locale:t2(tI()),location:t2(iT),page:t2(iC),screen:t2(iM),userAgent:t2(tI())}),nP=tD(n$,{componentId:tI(),experienceId:t2(tI()),variantIndex:t2(tj())}),nj=tD(nP,{sticky:t2(tT()),viewId:tI(),viewDurationMs:tj()}),nA=tD(nP,{viewId:t2(tI()),viewDurationMs:t2(tj())}),nT=tD(nP,{hoverId:tI(),hoverDurationMs:tj()}),nF=tD(n$,{traits:t2(iB),userId:tI()}),nC=tD(n$,{properties:t2(function(e,t){var i=void 0;let n=e._zod.def.checks;if(n&&n.length>0)throw Error(".partial() cannot be used on object schemas containing refinements");let r=eA(e._zod.def,{get shape(){let t=e._zod.def.shape,n={...t};if(i)for(let e in i){if(!(e in t))throw Error(`Unrecognized key: "${e}"`);i[e]&&(n[e]=t1?new t1({type:"optional",innerType:t[e]}):t[e])}else for(let e in t)n[e]=t1?new t1({type:"optional",innerType:t[e]}):t[e];return ej(this,"shape",n),n},checks:[]});return eB(e,r)}(iC))}),nR=tD(n$,{name:tI(),properties:iR}),nM=tD(n$,{event:tI(),properties:t2(t8(iR,{}))}),nB={path:"",query:{},referrer:"",search:"",title:"",url:""},nq=class{app;channel;library;getLocale;getPageProperties;getUserAgent;constructor(e){const{app:t,channel:i,library:n,getLocale:r,getPageProperties:s,getUserAgent:o}=e;this.app=t,this.channel=i,this.library=n,this.getLocale=r??(()=>"en-US"),this.getPageProperties=s??(()=>nB),this.getUserAgent=o??(()=>void 0)}buildUniversalEventProperties({campaign:e={},locale:t,location:i,page:n,screen:r,userAgent:s}){let o=new Date().toISOString();return{channel:this.channel,context:{app:this.app,campaign:e,gdpr:{isConsentGiven:!0},library:this.library,locale:t??this.getLocale()??"en-US",location:i,page:n??this.getPageProperties(),screen:r,userAgent:s??this.getUserAgent()},messageId:crypto.randomUUID(),originalTimestamp:o,sentAt:o,timestamp:o}}buildEntryInteractionBase(e,t,i,n){return{...this.buildUniversalEventProperties(e),componentType:"Entry",componentId:t,experienceId:i,variantIndex:n??0}}buildView(e){let{componentId:t,viewId:i,experienceId:n,variantIndex:r,viewDurationMs:s,...o}=na(nj,e);return{...this.buildEntryInteractionBase(o,t,n,r),type:"component",viewId:i,viewDurationMs:s}}buildClick(e){let{componentId:t,experienceId:i,variantIndex:n,...r}=na(nP,e);return{...this.buildEntryInteractionBase(r,t,i,n),type:"component_click"}}buildHover(e){let{hoverId:t,componentId:i,experienceId:n,hoverDurationMs:r,variantIndex:s,...o}=na(nT,e);return{...this.buildEntryInteractionBase(o,i,n,s),type:"component_hover",hoverId:t,hoverDurationMs:r}}buildFlagView(e){let{componentId:t,experienceId:i,variantIndex:n,viewId:r,viewDurationMs:s,...o}=na(nA,e);return{...this.buildEntryInteractionBase(o,t,i,n),...void 0===s?{}:{viewDurationMs:s},...void 0===r?{}:{viewId:r},type:"component",componentType:"Variable"}}buildIdentify(e){let{traits:t={},userId:i,...n}=na(nF,e);return{...this.buildUniversalEventProperties(n),type:"identify",traits:t,userId:i}}buildPageView(e={}){let{properties:t={},...i}=na(nC,e),n=this.getPageProperties(),r=function e(t,i){let n=Object.keys(i);for(let r=0;r<n.length;r++){let s=n[r];if("__proto__"===s)continue;let o=i[s],a=t[s];nI(o)&&nI(a)?t[s]=e(a,o):Array.isArray(o)?t[s]=e([],o):nk(o)?t[s]=e({},o):(void 0===a||void 0!==o)&&(t[s]=o)}return t}({...n,title:n.title??nB.title},t),{context:{screen:s,...o},...a}=this.buildUniversalEventProperties(i),l=na(iZ,o);return{...a,context:l,type:"page",properties:r}}buildScreenView(e){let{name:t,properties:i,...n}=na(nR,e),{context:{page:r,...s},...o}=this.buildUniversalEventProperties(n),a=na(iL,{...s,screen:s.screen??{name:t}});return{...o,context:a,type:"screen",name:t,properties:{name:t,...i}}}buildTrack(e){let{event:t,properties:i={},...n}=na(nM,e);return{...this.buildUniversalEventProperties(n),type:"track",event:t,properties:i}}};class nU{interceptors=new Map;nextId=0;add(e){let{nextId:t}=this;return this.nextId+=1,this.interceptors.set(t,e),t}remove(e){return this.interceptors.delete(e)}clear(){this.interceptors.clear()}count(){return this.interceptors.size}async run(e){let t=Array.from(this.interceptors.values()),i=e;for(let e of t)i=await e(ea(i));return i}}let nN={resolve:e=>e?e.reduce((e,{key:t,value:i})=>{let n="object"==typeof i&&null!==i&&"value"in i&&"object"==typeof i.value?i.value:i;return e[t]=n,e},{}):{}},nV=nu("Optimization"),nD="Could not resolve Merge Tag value:",nZ=(e,t)=>{if(!e||"object"!=typeof e)return;if(!t)return e;let i=e;for(let e of t.split(".").filter(Boolean)){if(!i||"object"!=typeof i&&"function"!=typeof i)return;i=Reflect.get(i,e)}return i},nQ={normalizeSelectors:e=>e.split("_").map((e,t,i)=>[i.slice(0,t).join("."),i.slice(t).join("_")].filter(e=>""!==e).join(".")),getValueFromProfile(e,t){let i=nQ.normalizeSelectors(e).find(e=>nZ(t,e));if(!i)return;let n=nZ(t,i);if(n&&("string"==typeof n||"number"==typeof n||"boolean"==typeof n))return`${n}`},resolve(e,t){if(!ih.safeParse(e).success)return void nV.warn(`${nD} supplied entry is not a Merge Tag entry`);let{fields:{nt_fallback:i}}=e;return i4.safeParse(t).success?nQ.getValueFromProfile(e.fields.nt_mergetag_id,t)??i:(nV.warn(`${nD} no valid profile`),i)}},nL=nu("Optimization"),nJ="Could not resolve optimized entry variant:",nH={getOptimizationEntry({optimizedEntry:e,selectedOptimizations:t},i=!1){if(i||t.length&&ik(e))return e.fields.nt_experiences.filter(e=>ix(e)).find(e=>t.some(({experienceId:t})=>t===e.fields.nt_experience_id))},getSelectedOptimization({optimizationEntry:e,selectedOptimizations:t},i=!1){if(i||t.length&&ix(e))return t.find(({experienceId:t})=>t===e.fields.nt_experience_id)},getSelectedVariant({optimizedEntry:e,optimizationEntry:t,selectedVariantIndex:i},n=!1){var r;if(!n&&(!ik(e)||!ix(t)))return;let s=(r=t.fields.nt_config,{distribution:r?.distribution===void 0?[]:[...r.distribution],traffic:r?.traffic??0,components:r?.components===void 0?[]:[...r.components],sticky:r?.sticky??!1}).components.filter(e=>("EntryReplacement"===e.type||void 0===e.type)&&!e.baseline.hidden).find(t=>t.baseline.id===e.sys.id)?.variants;if(s?.length)return s.at(i-1)},getSelectedVariantEntry({optimizationEntry:e,selectedVariant:t},i=!1){if(!i&&(!ix(e)||!iv.safeParse(t).success))return;let n=e.fields.nt_variants?.find(e=>e.sys.id===t.id);return ic.safeParse(n).success?n:void 0},resolve:function(e,t){if(nL.debug(`Resolving optimized entry for baseline entry ${e.sys.id}`),!t?.length)return nL.warn(`${nJ} no selectedOptimizations exist for the current profile`),{entry:e};if(!ik(e))return nL.warn(`${nJ} entry ${e.sys.id} is not optimized`),{entry:e};let i=nH.getOptimizationEntry({optimizedEntry:e,selectedOptimizations:t},!0);if(!i)return nL.warn(`${nJ} could not find an optimization entry for ${e.sys.id}`),{entry:e};let n=nH.getSelectedOptimization({optimizationEntry:i,selectedOptimizations:t},!0),r=n?.variantIndex??0;if(0===r)return nL.debug(`Resolved optimization entry for entry ${e.sys.id} is baseline`),{entry:e};let s=nH.getSelectedVariant({optimizedEntry:e,optimizationEntry:i,selectedVariantIndex:r},!0);if(!s)return nL.warn(`${nJ} could not find a valid replacement variant entry for ${e.sys.id}`),{entry:e};let o=nH.getSelectedVariantEntry({optimizationEntry:i,selectedVariant:s},!0);return o?(nL.debug(`Entry ${e.sys.id} has been resolved to variant entry ${o.sys.id}`),{entry:o,selectedOptimization:n}):(nL.warn(`${nJ} could not find a valid replacement variant entry for ${e.sys.id}`),{entry:e})}};class nK{api;eventBuilder;config;flagsResolver=nN;mergeTagValueResolver=nQ;optimizedEntryResolver=nH;interceptors={event:new nU,state:new nU};constructor(e,t={}){this.config=e;const{eventBuilder:i,logLevel:n,environment:r,clientId:s,fetchOptions:o}=e;nl.addSink(new nh(n));const a={clientId:s,environment:r,fetchOptions:o,experience:t.experience,insights:t.insights};this.api=new nx(a),this.eventBuilder=new nq(i??{channel:"server",library:{name:"@contentful/optimization-ios-bridge",version:"0.0.0"}})}getFlag(e,t){return this.flagsResolver.resolve(t)[e]}resolveOptimizedEntry(e,t){return this.optimizedEntryResolver.resolve(e,t)}getMergeTagValue(e,t){return this.mergeTagValueResolver.resolve(e,t)}}let nW=nK;function nG(){}function nX(e,t){return function e(t,i,n,r,s,o,a){let l=a(t,i,n,r,s,o);if(void 0!==l)return l;if(typeof t==typeof i)switch(typeof t){case"bigint":case"string":case"boolean":case"symbol":case"undefined":case"function":return t===i;case"number":return t===i||Object.is(t,i)}return function t(i,n,r,s){if(Object.is(i,n))return!0;let o=F(i),a=F(n);if(o===q&&(o=L),a===q&&(a=L),o!==a)return!1;switch(o){case R:return i.toString()===n.toString();case M:{let e=i.valueOf(),t=n.valueOf();return e===t||Number.isNaN(e)&&Number.isNaN(t)}case B:case N:case U:return Object.is(i.valueOf(),n.valueOf());case C:return i.source===n.source&&i.flags===n.flags;case"[object Function]":return i===n}let l=(r=r??new Map).get(i),u=r.get(n);if(null!=l&&null!=u)return l===n;r.set(i,n),r.set(n,i);try{switch(o){case V:if(i.size!==n.size)return!1;for(let[t,o]of i.entries())if(!n.has(t)||!e(o,n.get(t),t,i,n,r,s))return!1;return!0;case D:{if(i.size!==n.size)return!1;let t=Array.from(i.values()),o=Array.from(n.values());for(let a=0;a<t.length;a++){let l=t[a],u=o.findIndex(t=>e(l,t,void 0,i,n,r,s));if(-1===u)return!1;o.splice(u,1)}return!0}case Z:case H:case K:case W:case G:case"[object BigUint64Array]":case X:case Y:case ee:case"[object BigInt64Array]":case et:case ei:if(er(i)!==er(n)||i.length!==n.length)return!1;for(let t=0;t<i.length;t++)if(!e(i[t],n[t],t,i,n,r,s))return!1;return!0;case Q:if(i.byteLength!==n.byteLength)return!1;return t(new Uint8Array(i),new Uint8Array(n),r,s);case J:if(i.byteLength!==n.byteLength||i.byteOffset!==n.byteOffset)return!1;return t(new Uint8Array(i),new Uint8Array(n),r,s);case"[object Error]":return i.name===n.name&&i.message===n.message;case L:{if(!(t(i.constructor,n.constructor,r,s)||nk(i)&&nk(n)))return!1;let o=[...Object.keys(i),...T(i)],a=[...Object.keys(n),...T(n)];if(o.length!==a.length)return!1;for(let t=0;t<o.length;t++){let a=o[t],l=i[a];if(!Object.hasOwn(n,a))return!1;let u=n[a];if(!e(l,u,a,i,n,r,s))return!1}return!0}default:return!1}}finally{r.delete(i),r.delete(n)}}(t,i,o,a)}(e,t,void 0,void 0,void 0,void 0,nG)}let nY=nu("CoreStateful"),n0={trackView:"component",trackFlagView:"component",trackClick:"component_click",trackHover:"component_hover"};class n1 extends nW{flagObservables=new Map;getFlag(e,t=eu.value){let i=super.getFlag(e,t),n=this.buildFlagViewBuilderArgs(e,t);return this.trackFlagView(n).catch(t=>{nl.warn(`Failed to emit "flag view" event for "${e}"`,String(t))}),i}resolveOptimizedEntry(e,t=ey.value){return super.resolveOptimizedEntry(e,t)}getMergeTagValue(e,t=em.value){return super.getMergeTagValue(e,t)}async identify(e){let{profile:t,...i}=e;return await this.sendExperienceEvent("identify",[e],this.eventBuilder.buildIdentify(i),t)}async page(e={}){let{profile:t,...i}=e;return await this.sendExperienceEvent("page",[e],this.eventBuilder.buildPageView(i),t)}async screen(e){let{profile:t,...i}=e;return await this.sendExperienceEvent("screen",[e],this.eventBuilder.buildScreenView(i),t)}async track(e){let{profile:t,...i}=e;return await this.sendExperienceEvent("track",[e],this.eventBuilder.buildTrack(i),t)}async trackView(e){let t,{profile:i,...n}=e;return e.sticky&&(t=await this.sendExperienceEvent("trackView",[e],this.eventBuilder.buildView(n),i)),await this.sendInsightsEvent("trackView",[e],this.eventBuilder.buildView(n),i),t}async trackClick(e){await this.sendInsightsEvent("trackClick",[e],this.eventBuilder.buildClick(e))}async trackHover(e){await this.sendInsightsEvent("trackHover",[e],this.eventBuilder.buildHover(e))}async trackFlagView(e){await this.sendInsightsEvent("trackFlagView",[e],this.eventBuilder.buildFlagView(e))}hasConsent(e){let{[e]:t}=n0,i=void 0!==t?this.allowedEventTypes.includes(t):this.allowedEventTypes.some(t=>t===e);return!!ed.value||i}onBlockedByConsent(e,t){nY.warn(`Event "${e}" was blocked due to lack of consent; payload: ${JSON.stringify(t)}`),this.reportBlockedEvent("consent",e,t)}async sendExperienceEvent(e,t,i,n){return this.hasConsent(e)?await this.experienceQueue.send(i):void this.onBlockedByConsent(e,t)}async sendInsightsEvent(e,t,i,n){this.hasConsent(e)?await this.insightsQueue.send(i):this.onBlockedByConsent(e,t)}buildFlagViewBuilderArgs(e,t=eu.value){let i=t?.find(t=>t.key===e);return{componentId:e,experienceId:i?.meta.experienceId,variantIndex:i?.meta.variantIndex}}getFlagObservable(e){var t;let i,n=this.flagObservables.get(e);if(n)return n;let r=this.trackFlagView.bind(this),s=this.buildFlagViewBuilderArgs.bind(this),o=(t=ew.computed(()=>super.getFlag(e,eu.value)),i=el(t),{get current(){return i.current},subscribe(e){let t=!1,n=ea(i.current);return i.subscribe(i=>{t&&nX(n,i)||(t=!0,n=ea(i),e(i))})},subscribeOnce:e=>i.subscribeOnce(e)}),a={get current(){let{current:t}=o;return r(s(e,eu.value)).catch(t=>{nl.warn(`Failed to emit "flag view" event for "${e}"`,String(t))}),t},subscribe:t=>o.subscribe(i=>{r(s(e,eu.value)).catch(t=>{nl.warn(`Failed to emit "flag view" event for "${e}"`,String(t))}),t(i)}),subscribeOnce:t=>o.subscribeOnce(i=>{r(s(e,eu.value)).catch(t=>{nl.warn(`Failed to emit "flag view" event for "${e}"`,String(t))}),t(i)})};return this.flagObservables.set(e,a),a}reportBlockedEvent(e,t,i){let n={reason:e,method:t,args:i};try{this.onEventBlocked?.(n)}catch(e){nY.warn(`onEventBlocked callback failed for method "${t}"`,e)}ec.value=n}}let n2=n1,n6=(e,t)=>!Number.isFinite(e)||void 0===e||e<1?t:Math.floor(e),n3={flushIntervalMs:3e4,baseBackoffMs:500,maxBackoffMs:3e4,jitterRatio:.2,maxConsecutiveFailures:8,circuitOpenMs:12e4},n4="__ctfl_optimization_stateful_runtime_lock__",n8=()=>{let e=globalThis;return e[n4]??={owner:void 0},e[n4]},n5=e=>{let t=n8();t.owner===e&&(t.owner=void 0)};class n9{circuitOpenUntil=0;flushFailureCount=0;flushInFlight=!1;nextFlushAllowedAt=0;onCallbackError;onRetry;policy;retryTimer;constructor(e){const{onCallbackError:t,onRetry:i,policy:n}=e;this.policy=n,this.onRetry=i,this.onCallbackError=t}reset(){this.clearScheduledRetry(),this.circuitOpenUntil=0,this.flushFailureCount=0,this.flushInFlight=!1,this.nextFlushAllowedAt=0}clearScheduledRetry(){void 0!==this.retryTimer&&(clearTimeout(this.retryTimer),this.retryTimer=void 0)}shouldSkip(e){let{force:t,isOnline:i}=e;if(this.flushInFlight)return!0;if(t)return!1;if(!i)return!0;let n=Date.now();return!!(this.nextFlushAllowedAt>n)||!!(this.circuitOpenUntil>n)}markFlushStarted(){this.flushInFlight=!0}markFlushFinished(){this.flushInFlight=!1}handleFlushSuccess(){let{flushFailureCount:e}=this;this.clearScheduledRetry(),this.circuitOpenUntil=0,this.flushFailureCount=0,this.nextFlushAllowedAt=0,e<=0||this.safeInvoke("onFlushRecovered",{consecutiveFailures:e})}handleFlushFailure(e){let{queuedBatches:t,queuedEvents:i}=e;this.flushFailureCount+=1;let n=(e=>{let{consecutiveFailures:t,policy:{baseBackoffMs:i,jitterRatio:n,maxBackoffMs:r}}=e,s=Math.min(r,i*2**Math.max(0,t-1)),o=s*n*Math.random();return Math.round(s+o)})({consecutiveFailures:this.flushFailureCount,policy:this.policy}),r=Date.now(),s={consecutiveFailures:this.flushFailureCount,queuedBatches:t,queuedEvents:i,retryDelayMs:n};this.safeInvoke("onFlushFailure",s);let{circuitOpenUntil:o,nextFlushAllowedAt:a,openedCircuit:l,retryDelayMs:u}=(e=>{let{consecutiveFailures:t,failureTimestamp:i,retryDelayMs:n,policy:{maxConsecutiveFailures:r,circuitOpenMs:s}}=e;if(t<r)return{openedCircuit:!1,retryDelayMs:n,nextFlushAllowedAt:i+n,circuitOpenUntil:0};let o=i+s;return{openedCircuit:!0,retryDelayMs:s,nextFlushAllowedAt:o,circuitOpenUntil:o}})({consecutiveFailures:this.flushFailureCount,failureTimestamp:r,retryDelayMs:n,policy:this.policy});this.nextFlushAllowedAt=a,l&&(this.circuitOpenUntil=o,this.safeInvoke("onCircuitOpen",{...s,retryDelayMs:u})),this.scheduleRetry(u)}scheduleRetry(e){this.clearScheduledRetry(),this.retryTimer=setTimeout(()=>{this.retryTimer=void 0,this.onRetry()},e)}safeInvoke(...e){let[t,i]=e;try{if("onFlushRecovered"===t)return void this.policy.onFlushRecovered?.(i);if("onCircuitOpen"===t)return void this.policy.onCircuitOpen?.(i);this.policy.onFlushFailure?.(i)}catch(e){this.onCallbackError?.(t,e)}}}let n7=nu("CoreStateful");class re{experienceApi;eventInterceptors;flushRuntime;getAnonymousId;offlineMaxEvents;onOfflineDrop;queuedExperienceEvents=new Set;stateInterceptors;constructor(e){const{experienceApi:t,eventInterceptors:i,flushPolicy:n,getAnonymousId:r,offlineMaxEvents:s,onOfflineDrop:o,stateInterceptors:a}=e;this.experienceApi=t,this.eventInterceptors=i,this.getAnonymousId=r,this.offlineMaxEvents=s,this.onOfflineDrop=o,this.stateInterceptors=a,this.flushRuntime=new n9({policy:n,onRetry:()=>{this.flush()},onCallbackError:(e,t)=>{n7.warn(`Experience flush policy callback "${e}" failed`,t)}})}clearScheduledRetry(){this.flushRuntime.clearScheduledRetry()}async send(e){let t=na(iY,await this.eventInterceptors.run(e));if(ep.value=t,eh.value)return await this.upsertProfile([t]);n7.debug(`Queueing ${t.type} event`,t),this.enqueueEvent(t)}async flush(e={}){let{force:t=!1}=e;if(this.flushRuntime.shouldSkip({force:t,isOnline:!!eh.value}))return;if(0===this.queuedExperienceEvents.size)return void this.flushRuntime.clearScheduledRetry();n7.debug("Flushing offline Experience event queue");let i=Array.from(this.queuedExperienceEvents);this.flushRuntime.markFlushStarted();try{await this.tryUpsertQueuedEvents(i)?(i.forEach(e=>{this.queuedExperienceEvents.delete(e)}),this.flushRuntime.handleFlushSuccess()):this.flushRuntime.handleFlushFailure({queuedBatches:+(this.queuedExperienceEvents.size>0),queuedEvents:this.queuedExperienceEvents.size})}finally{this.flushRuntime.markFlushFinished()}}enqueueEvent(e){let t=[];if(this.queuedExperienceEvents.size>=this.offlineMaxEvents){let e=this.queuedExperienceEvents.size-this.offlineMaxEvents+1;(t=this.dropOldestEvents(e)).length>0&&n7.warn(`Dropped ${t.length} oldest offline event(s) due to queue limit (${this.offlineMaxEvents})`)}this.queuedExperienceEvents.add(e),t.length>0&&this.invokeOfflineDropCallback({droppedCount:t.length,droppedEvents:t,maxEvents:this.offlineMaxEvents,queuedEvents:this.queuedExperienceEvents.size})}dropOldestEvents(e){let t=[];for(let i=0;i<e;i+=1){let e=this.queuedExperienceEvents.values().next();if(e.done)break;this.queuedExperienceEvents.delete(e.value),t.push(e.value)}return t}invokeOfflineDropCallback(e){try{this.onOfflineDrop?.(e)}catch(e){n7.warn("Offline queue drop callback failed",e)}}async tryUpsertQueuedEvents(e){try{return await this.upsertProfile(e),!0}catch(e){return n7.warn("Experience queue flush request threw an error",e),!1}}async upsertProfile(e){let t=this.getAnonymousId();t&&n7.debug(`Anonymous ID found: ${t}`);let i=await this.experienceApi.upsertProfile({profileId:t??em.value?.id,events:e});return await this.updateOutputSignals(i),i}async updateOutputSignals(e){let{changes:t,profile:i,selectedOptimizations:n}=await this.stateInterceptors.run(e);p(()=>{nX(eu.value,t)||(eu.value=t),nX(em.value,i)||(em.value=i),nX(ey.value,n)||(ey.value=n)})}}let rt=nu("CoreStateful");class ri{eventInterceptors;flushIntervalMs;flushRuntime;insightsApi;queuedInsightsByProfile=new Map;insightsPeriodicFlushTimer;constructor(e){const{eventInterceptors:t,flushPolicy:i,insightsApi:n}=e,{flushIntervalMs:r}=i;this.eventInterceptors=t,this.flushIntervalMs=r,this.insightsApi=n,this.flushRuntime=new n9({policy:i,onRetry:()=>{this.flush()},onCallbackError:(e,t)=>{rt.warn(`Insights flush policy callback "${e}" failed`,t)}})}clearScheduledRetry(){this.flushRuntime.clearScheduledRetry()}clearPeriodicFlushTimer(){void 0!==this.insightsPeriodicFlushTimer&&(clearInterval(this.insightsPeriodicFlushTimer),this.insightsPeriodicFlushTimer=void 0)}async send(e){let{value:t}=em;if(!t)return void rt.warn("Attempting to emit an event without an Optimization profile");let i=na(nr,await this.eventInterceptors.run(e));rt.debug(`Queueing ${i.type} event for profile ${t.id}`,i);let n=this.queuedInsightsByProfile.get(t.id);ep.value=i,n?(n.profile=t,n.events.push(i)):this.queuedInsightsByProfile.set(t.id,{profile:t,events:[i]}),this.ensurePeriodicFlushTimer(),this.getQueuedEventCount()>=25&&await this.flush(),this.reconcilePeriodicFlushTimer()}async flush(e={}){let{force:t=!1}=e;if(this.flushRuntime.shouldSkip({force:t,isOnline:!!eh.value}))return;rt.debug("Flushing insights event queue");let i=this.createBatches();if(!i.length){this.flushRuntime.clearScheduledRetry(),this.reconcilePeriodicFlushTimer();return}this.flushRuntime.markFlushStarted();try{await this.trySendBatches(i)?(this.queuedInsightsByProfile.clear(),this.flushRuntime.handleFlushSuccess()):this.flushRuntime.handleFlushFailure({queuedBatches:i.length,queuedEvents:this.getQueuedEventCount()})}finally{this.flushRuntime.markFlushFinished(),this.reconcilePeriodicFlushTimer()}}createBatches(){let e=[];return this.queuedInsightsByProfile.forEach(({profile:t,events:i})=>{e.push({profile:t,events:i})}),e}async trySendBatches(e){try{return await this.insightsApi.sendBatchEvents(e)}catch(e){return rt.warn("Insights queue flush request threw an error",e),!1}}getQueuedEventCount(){let e=0;return this.queuedInsightsByProfile.forEach(({events:t})=>{e+=t.length}),e}ensurePeriodicFlushTimer(){void 0!==this.insightsPeriodicFlushTimer||0!==this.getQueuedEventCount()&&(this.insightsPeriodicFlushTimer=setInterval(()=>{this.flush()},this.flushIntervalMs))}reconcilePeriodicFlushTimer(){this.getQueuedEventCount()>0?this.ensurePeriodicFlushTimer():this.clearPeriodicFlushTimer()}}let rn=Symbol.for("ctfl.optimization.preview.signals"),rr=Symbol.for("ctfl.optimization.preview.signalFns"),rs=nu("CoreStateful"),ro=["identify","page","screen"],ra=e=>Object.values(e).some(e=>void 0!==e),rl=0;class ru extends n2{singletonOwner;destroyed=!1;allowedEventTypes;experienceQueue;insightsQueue;onEventBlocked;states={blockedEventStream:el(ec),flag:e=>this.getFlagObservable(e),consent:el(ed),eventStream:el(ep),canOptimize:el(eg),selectedOptimizations:el(ey),previewPanelAttached:el(ef),previewPanelOpen:el(ev),profile:el(em)};constructor(e){super(e,{experience:(e=>{if(void 0===e)return;let t={baseUrl:e.experienceBaseUrl,enabledFeatures:e.enabledFeatures,ip:e.ip,locale:e.locale,plainText:e.plainText,preflight:e.preflight};return ra(t)?t:void 0})(e.api),insights:(e=>{if(void 0===e)return;let t={baseUrl:e.insightsBaseUrl,beaconHandler:e.beaconHandler};return ra(t)?t:void 0})(e.api)}),this.singletonOwner=`CoreStateful#${++rl}`,(e=>{let t=n8();if(t.owner)throw Error(`Stateful Optimization SDK already initialized (${t.owner}). Only one stateful instance is supported per runtime.`);t.owner=e})(this.singletonOwner);try{const{allowedEventTypes:t,defaults:i,getAnonymousId:n,onEventBlocked:r,queuePolicy:s}=e,{changes:o,consent:a,selectedOptimizations:l,profile:u}=i??{},c=(e=>({flush:((e,t=n3)=>{var i,n;let r=e??{},s=n6(r.baseBackoffMs,t.baseBackoffMs),o=Math.max(s,n6(r.maxBackoffMs,t.maxBackoffMs));return{flushIntervalMs:n6(r.flushIntervalMs,t.flushIntervalMs),baseBackoffMs:s,maxBackoffMs:o,jitterRatio:(i=r.jitterRatio,n=t.jitterRatio,Number.isFinite(i)&&void 0!==i?Math.min(1,Math.max(0,i)):n),maxConsecutiveFailures:n6(r.maxConsecutiveFailures,t.maxConsecutiveFailures),circuitOpenMs:n6(r.circuitOpenMs,t.circuitOpenMs),onCircuitOpen:r.onCircuitOpen,onFlushFailure:r.onFlushFailure,onFlushRecovered:r.onFlushRecovered}})(e?.flush),offlineMaxEvents:n6(e?.offlineMaxEvents,100),onOfflineDrop:e?.onOfflineDrop}))(s);this.allowedEventTypes=t??ro,this.onEventBlocked=r,this.insightsQueue=new ri({eventInterceptors:this.interceptors.event,flushPolicy:c.flush,insightsApi:this.api.insights}),this.experienceQueue=new re({experienceApi:this.api.experience,eventInterceptors:this.interceptors.event,flushPolicy:c.flush,getAnonymousId:n??(()=>void 0),offlineMaxEvents:c.offlineMaxEvents,onOfflineDrop:c.onOfflineDrop,stateInterceptors:this.interceptors.state}),void 0!==a&&(ed.value=a),p(()=>{void 0!==o&&(eu.value=o),void 0!==l&&(ey.value=l),void 0!==u&&(em.value=u)}),this.initializeEffects()}catch(e){throw n5(this.singletonOwner),e}}initializeEffects(){A(()=>{rs.debug(`Profile ${em.value&&`with ID ${em.value.id}`} has been ${em.value?"set":"cleared"}`)}),A(()=>{rs.debug(`Variants have been ${ey.value?.length?"populated":"cleared"}`)}),A(()=>{rs.info(`Core ${ed.value?"will":"will not"} emit gated events due to consent (${ed.value})`)}),A(()=>{eh.value&&(this.insightsQueue.clearScheduledRetry(),this.experienceQueue.clearScheduledRetry(),this.flushQueues({force:!0}))})}async flushQueues(e={}){await this.insightsQueue.flush(e),await this.experienceQueue.flush(e)}destroy(){this.destroyed||(this.destroyed=!0,this.insightsQueue.flush({force:!0}).catch(e=>{nl.warn("Failed to flush insights queue during destroy()",String(e))}),this.experienceQueue.flush({force:!0}).catch(e=>{nl.warn("Failed to flush Experience queue during destroy()",String(e))}),this.insightsQueue.clearPeriodicFlushTimer(),n5(this.singletonOwner))}reset(){p(()=>{ec.value=void 0,ep.value=void 0,eu.value=void 0,em.value=void 0,ey.value=void 0})}async flush(){await this.flushQueues()}consent(e){ed.value=e}get online(){return eh.value??!1}set online(e){eh.value=e}registerPreviewPanel(e){Reflect.set(e,rn,eb),Reflect.set(e,rr,ew)}}let rc="ALL_VISITORS";function rd(e,t){let{audiences:{[t]:i}}=e;return i?i.isActive?"on":"off":"default"}function rp(e,t){return"on"===e||"off"!==e&&t}function rh(e,t,i,n){let r=t[e.id]??0,s=void 0!==i.selectedOptimizations[e.id],o={...e,currentVariantIndex:r,isOverridden:s};if(s&&void 0!==n){let{[e.id]:t}=n;void 0!==t&&(o.naturalVariantIndex=t)}return o}function rf(e,t){let i=Object.values(t);if(0===i.length)return e;let n=e.map(e=>{let{[e.experienceId]:i}=t;return i?{...e,variantIndex:i.variantIndex}:e});for(let e of i)n.some(t=>t.experienceId===e.experienceId)||n.push({experienceId:e.experienceId,variantIndex:e.variantIndex,variants:{}});return n}nu("Preview");let rv=nu("PreviewOverrides"),ry={audiences:{},selectedOptimizations:{}};class rg{baselineSelectedOptimizations=null;baselineAudienceQualifications={};overrides={...ry,audiences:{},selectedOptimizations:{}};interceptorId=null;selectedOptimizations;profile;stateInterceptors;onOverridesChanged;constructor(e){const{selectedOptimizations:t,profile:i,stateInterceptors:n,onOverridesChanged:r}=e;this.selectedOptimizations=t,this.profile=i,this.stateInterceptors=n,this.onOverridesChanged=r;const{value:s}=t;s&&(this.baselineSelectedOptimizations=s,rv.debug("Captured initial signal state as baseline")),this.interceptorId=e.stateInterceptors.add(e=>{let{selectedOptimizations:t}=e;this.baselineSelectedOptimizations=t;let i=Object.keys(this.overrides.selectedOptimizations).length>0,n=i?{...e,selectedOptimizations:rf(e.selectedOptimizations,this.overrides.selectedOptimizations)}:{...e};return i&&rv.debug("Intercepting state update to preserve overrides"),this.notifyChanged(),n}),rv.info("State interceptor registered")}activateAudience(e,t){rv.info("Activating audience override:",e),this.setAudienceOverride(e,!0,1,t)}deactivateAudience(e,t){rv.info("Deactivating audience override:",e),this.setAudienceOverride(e,!1,0,t)}resetAudienceOverride(e){rv.info("Resetting audience override:",e);let{overrides:t}=this,{audiences:i,selectedOptimizations:n}=t,r=i[e]?.experienceIds??[],s=new Set(r),o=Object.fromEntries(Object.entries(n).filter(([e])=>!s.has(e))),a=Object.fromEntries(Object.entries(i).filter(([t])=>t!==e));this.overrides={audiences:a,selectedOptimizations:o},this.baselineAudienceQualifications=Object.fromEntries(Object.entries(this.baselineAudienceQualifications).filter(([t])=>t!==e)),r.length>0&&this.syncOverridesToSignal(),this.notifyChanged()}setVariantOverride(e,t){rv.info("Setting variant override:",{experienceId:e,variantIndex:t}),this.overrides={...this.overrides,selectedOptimizations:{...this.overrides.selectedOptimizations,[e]:{experienceId:e,variantIndex:t}}},this.syncOverridesToSignal(),this.notifyChanged()}resetOptimizationOverride(e){rv.info("Resetting optimization override:",e);let{selectedOptimizations:t}={...this.overrides},i=Object.fromEntries(Object.entries(t).filter(([t])=>t!==e));this.overrides={...this.overrides,selectedOptimizations:i},this.syncOverridesToSignal(),this.notifyChanged()}resetAll(){rv.info("Resetting all overrides to baseline"),this.overrides={audiences:{},selectedOptimizations:{}},this.baselineAudienceQualifications={};let{baselineSelectedOptimizations:e}=this;e&&(this.selectedOptimizations.value=e,rv.debug("Restored signal to baseline")),this.notifyChanged()}getOverrides(){return this.overrides}getBaselineSelectedOptimizations(){return this.baselineSelectedOptimizations}getBaselineAudienceQualifications(){return this.baselineAudienceQualifications}destroy(){null!==this.interceptorId&&(this.stateInterceptors.remove(this.interceptorId),rv.info("State interceptor removed"),this.interceptorId=null),this.overrides={audiences:{},selectedOptimizations:{}},this.baselineSelectedOptimizations=null,this.baselineAudienceQualifications={}}snapshotAudienceQualification(e){if(!this.profile||e in this.baselineAudienceQualifications)return;let t=this.profile.value?.audiences.includes(e)??!1;this.baselineAudienceQualifications[e]=t}syncOverridesToSignal(){this.selectedOptimizations.value=rf(this.baselineSelectedOptimizations??[],this.overrides.selectedOptimizations),rv.debug("Synced overrides to signal")}setAudienceOverride(e,t,i,n){this.snapshotAudienceQualification(e);let r={...this.overrides.selectedOptimizations};for(let e of n)r[e]={experienceId:e,variantIndex:i};this.overrides={audiences:{...this.overrides.audiences,[e]:{audienceId:e,isActive:t,source:"manual",experienceIds:n}},selectedOptimizations:r},n.length>0&&this.syncOverridesToSignal(),this.notifyChanged()}notifyChanged(){this.onOverridesChanged?.(this.overrides)}}let rm=null,rb=null,rw=null,r_=null,rz=null,rO=null,rS={},rE={},rx={initialize(e){rm&&rx.destroy(),rz=null,rO=null,rS={},rE={},rm=new ru({clientId:e.clientId,environment:e.environment,api:{experienceBaseUrl:e.experienceBaseUrl,insightsBaseUrl:e.insightsBaseUrl}}),e.defaults&&(void 0!==e.defaults.consent&&rm.consent(e.defaults.consent),void 0!==e.defaults.profile&&(eb.profile.value=e.defaults.profile),void 0!==e.defaults.changes&&(eb.changes.value=e.defaults.changes),void 0!==e.defaults.optimizations&&(eb.selectedOptimizations.value=e.defaults.optimizations)),rm.consent(!0);let t=globalThis;r_=new rg({selectedOptimizations:eb.selectedOptimizations,profile:eb.profile,stateInterceptors:rm.interceptors.state,onOverridesChanged:()=>{"function"==typeof t.__nativeOnOverridesChanged&&t.__nativeOnOverridesChanged(rx.getPreviewState())}}),rb=A(()=>{let e={profile:eb.profile.value??null,consent:eb.consent.value,canPersonalize:eb.canOptimize.value,changes:eb.changes.value??null,selectedPersonalizations:eb.selectedOptimizations.value??null};"function"==typeof t.__nativeOnStateChange&&t.__nativeOnStateChange(JSON.stringify(e))}),rw=A(()=>{let e=eb.event.value;e&&"function"==typeof t.__nativeOnEventEmitted&&t.__nativeOnEventEmitted(JSON.stringify(e))})},identify(e,t,i){rm?rm.identify(e).then(e=>{t(JSON.stringify(e??null))}).catch(e=>{i(e instanceof Error?e.message:String(e))}):i("SDK not initialized. Call initialize() first.")},page(e,t,i){rm?rm.page(e).then(e=>{t(JSON.stringify(e??null))}).catch(e=>{i(e instanceof Error?e.message:String(e))}):i("SDK not initialized. Call initialize() first.")},screen(e,t,i){rm?rm.screen({name:e.name,properties:e.properties??{}}).then(e=>{t(JSON.stringify(e??null))}).catch(e=>{i(e instanceof Error?e.message:String(e))}):i("SDK not initialized. Call initialize() first.")},flush(e,t){rm?rm.flush().then(()=>{e(JSON.stringify(null))}).catch(e=>{t(e instanceof Error?e.message:String(e))}):t("SDK not initialized. Call initialize() first.")},trackView(e,t,i){rm?rm.trackView(e).then(e=>{t(JSON.stringify(e??null))}).catch(e=>{i(e instanceof Error?e.message:String(e))}):i("SDK not initialized. Call initialize() first.")},trackClick(e,t,i){rm?rm.trackClick(e).then(()=>{t(JSON.stringify(null))}).catch(e=>{i(e instanceof Error?e.message:String(e))}):i("SDK not initialized. Call initialize() first.")},consent(e){rm&&rm.consent(e)},reset(){rm&&(r_?.resetAll(),rm.reset())},setOnline(e){eb.online.value=e},personalizeEntry:(e,t)=>rm?JSON.stringify(rm.resolveOptimizedEntry(e,t)):JSON.stringify({entry:e}),setPreviewPanelOpen(e){rm&&(eb.previewPanelOpen.value=e)},overrideAudience(e,t,i){r_&&(t?r_.activateAudience(e,i):r_.deactivateAudience(e,i))},overrideVariant(e,t){r_?.setVariantOverride(e,t)},resetAudienceOverride(e){r_?.resetAudienceOverride(e)},resetVariantOverride(e){r_?.resetOptimizationOverride(e)},resetAllOverrides(){r_?.resetAll()},loadDefinitions(e,t){try{let i,n;for(let r of(rz=e.map(e=>{let t=e.fields;return"object"==typeof t&&null!==t?{id:t.nt_audience_id??e.sys.id,name:t.nt_name??t.nt_audience_id??e.sys.id,description:t.nt_description}:{id:e.sys.id,name:e.sys.id}}),i=new Map,t.forEach(e=>{(e.includes?.Entry??[]).forEach(e=>{i.set(e.sys.id,e)})}),rO=t.map(e=>{let t=e.fields;if("object"!=typeof t||null===t)return{id:e.sys.id,name:e.sys.id,type:"nt_personalization",distribution:[]};let{nt_config:n}=t,r=[];return n?.distribution&&n.distribution.forEach((e,t)=>{let s,o=(s=n.components?.[0],void 0===s||void 0!==s.type&&"EntryReplacement"!==s.type?"":0===t?s.baseline.id:s.variants[t-1]?.id??""),a=i.get(o);r.push({index:t,variantRef:o,percentage:Math.round(100*e),name:a?function(e){let t=e.fields;if("object"==typeof t&&null!==t)return t.internalTitle??t.title??t.name}(a):void 0})}),{id:t.nt_experience_id??e.sys.id,name:t.nt_name??e.sys.id,type:t.nt_type??"nt_personalization",distribution:r,audience:t.nt_audience?{id:t.nt_audience.sys.id}:void 0}}),n={},t.forEach(e=>{let t=e.fields;if("object"==typeof t&&null!==t){let i=t.nt_personalization_id??t.nt_experience_id??e.sys.id,{nt_name:r}=t;r&&(n[i]=r)}}),rE=n,rS={},rz))rS[r.id]=r.name;return JSON.stringify({audienceCount:rz.length,experienceCount:rO.length})}catch(e){return rz=null,rO=null,rS={},rE={},JSON.stringify({error:e instanceof Error?e.message:String(e)})}},getPreviewState(){let e=r_?.getOverrides()??{audiences:{},selectedOptimizations:{}},t=r_?.getBaselineSelectedOptimizations(),i={};for(let[t,n]of Object.entries(e.audiences))i[t]=n.isActive;let n={};for(let[t,i]of Object.entries(e.selectedOptimizations))n[t]=i.variantIndex;let r={};if(t)for(let e of t)void 0!==n[e.experienceId]&&(r[e.experienceId]=e.variantIndex);let s=rz&&rO?{...function(e){let{audienceDefinitions:t,experienceDefinitions:i,signals:n,overrides:r}=e,{profile:s,selectedOptimizations:o}=n,a=new Set(s?.audiences??[]),l={};if(o)for(let{experienceId:e,variantIndex:t}of o)l[e]=t;let u=null!=e.baselineSelectedOptimizations?Object.fromEntries(e.baselineSelectedOptimizations.map(e=>[e.experienceId,e.variantIndex])):void 0,c=new Set(t.map(e=>e.id)),d=i.filter(e=>!e.audience?.id||!c.has(e.audience.id)).map(e=>rh(e,l,r,u)),p=t.map(e=>{let t=i.filter(t=>t.audience?.id===e.id).map(e=>rh(e,l,r,u)),n=a.has(e.id),s=rd(r,e.id),o=rp(s,n);return{audience:e,experiences:t,isQualified:n,isActive:o,overrideState:s}});if(d.length>0){let e=rd(r,rc);p.push({audience:{id:rc,name:"All Visitors",description:"Experiences that apply to all visitors regardless of audience membership"},experiences:d,isQualified:!0,isActive:rp(e,!0),overrideState:e})}let h=t.length>0||i.length>0;return{audiencesWithExperiences:[...p].sort((e,t)=>e.audience.id===rc?-1:t.audience.id===rc?1:e.isActive!==t.isActive?e.isActive?-1:1:e.audience.name.localeCompare(t.audience.name,void 0,{sensitivity:"base"})),unassociatedExperiences:d,hasData:h,sdkVariantIndices:l}}({audienceDefinitions:rz,experienceDefinitions:rO,signals:{profile:eb.profile.value,selectedOptimizations:eb.selectedOptimizations.value,consent:eb.consent.value,isLoading:!1},overrides:e,baselineSelectedOptimizations:t}),audienceNameMap:rS,experienceNameMap:rE}:null;return JSON.stringify({profile:eb.profile.value??null,consent:eb.consent.value,canPersonalize:eb.canOptimize.value,changes:eb.changes.value??null,selectedPersonalizations:eb.selectedOptimizations.value??null,previewPanelOpen:eb.previewPanelOpen.value,audienceOverrides:i,variantOverrides:n,defaultAudienceQualifications:r_?.getBaselineAudienceQualifications()??{},defaultVariantIndices:r,previewModel:s})},getProfile(){let e=eb.profile.value;return e?JSON.stringify(e):null},getState:()=>JSON.stringify({profile:eb.profile.value??null,consent:eb.consent.value,canPersonalize:eb.canOptimize.value,changes:eb.changes.value??null,selectedPersonalizations:eb.selectedOptimizations.value??null}),destroy(){r_?.destroy(),r_=null,rz=null,rO=null,rS={},rE={},rw&&(rw(),rw=null),rb&&(rb(),rb=null),rm&&(rm.destroy(),rm=null)}};globalThis.__bridge=rx;let rk=rx;return u.default})());
+//# sourceMappingURL=optimization-ios-bridge.umd.js.map
\ No newline at end of file
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Storage/PersistentStore.swift b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Storage/PersistentStore.swift
index 9610d0d3..3d97c4da 100644
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Storage/PersistentStore.swift
+++ b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Storage/PersistentStore.swift
@@ -4,7 +4,7 @@ import Foundation
 protocol PersistentStore {
     var profile: [String: Any]? { get set }
     var consent: Bool? { get set }
-    var changes: [String: Any]? { get set }
+    var changes: [[String: Any]]? { get set }
     var personalizations: [[String: Any]]? { get set }
     var anonymousId: String? { get set }
     var debug: Bool { get set }
diff --git a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Storage/UserDefaultsStore.swift b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Storage/UserDefaultsStore.swift
index 56e21f36..524cd8db 100644
--- a/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Storage/UserDefaultsStore.swift
+++ b/packages/ios/ContentfulOptimization/Sources/ContentfulOptimization/Storage/UserDefaultsStore.swift
@@ -75,8 +75,8 @@ final class UserDefaultsStore: PersistentStore {
         }
     }
 
-    var changes: [String: Any]? {
-        get { cache["changes"] as? [String: Any] }
+    var changes: [[String: Any]]? {
+        get { cache["changes"] as? [[String: Any]] }
         set {
             cache["changes"] = newValue
             writeJSON(newValue, forKey: "changes")
diff --git a/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/OptimizationClientTests.swift b/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/OptimizationClientTests.swift
index db2662f7..ba2f14a9 100644
--- a/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/OptimizationClientTests.swift
+++ b/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/OptimizationClientTests.swift
@@ -43,6 +43,31 @@ final class OptimizationClientTests: XCTestCase {
         XCTAssertEqual(dict["environment"], "master")
     }
 
+    func testConfigSerializesDefaultsAsOptimizationsKey() throws {
+        let seeded: [[String: Any]] = [
+            ["experienceId": "exp-1", "variantIndex": 2]
+        ]
+        let config = OptimizationConfig(
+            clientId: "test",
+            defaults: StorageDefaults(personalizations: seeded)
+        )
+
+        let json = try config.toJSON()
+        let data = json.data(using: .utf8)!
+        let dict = try JSONSerialization.jsonObject(with: data) as! [String: Any]
+        let defaults = dict["defaults"] as? [String: Any]
+
+        XCTAssertNotNil(defaults?["optimizations"],
+                        "Bridge reads defaults.optimizations; Swift must serialize under that key")
+        XCTAssertNil(defaults?["personalizations"],
+                     "Old key name must not be emitted")
+
+        let optimizations = defaults?["optimizations"] as? [[String: Any]]
+        XCTAssertEqual(optimizations?.count, 1)
+        XCTAssertEqual(optimizations?.first?["experienceId"] as? String, "exp-1")
+        XCTAssertEqual(optimizations?.first?["variantIndex"] as? Int, 2)
+    }
+
     // MARK: - State Tests
 
     func testOptimizationStateEmpty() {
@@ -74,15 +99,15 @@ final class OptimizationClientTests: XCTestCase {
             profile: ["userId": "u1", "email": "a@b.com", "plan": "pro"] as [String: Any],
             consent: true,
             canPersonalize: true,
-            changes: ["fieldA": "x", "fieldB": 42, "fieldC": true] as [String: Any]
+            changes: [["key": "hero", "value": "A"] as [String: Any]]
         )
         let b = OptimizationState(
             profile: ["plan": "pro", "email": "a@b.com", "userId": "u1"] as [String: Any],
             consent: true,
             canPersonalize: true,
-            changes: ["fieldC": true, "fieldA": "x", "fieldB": 42] as [String: Any]
+            changes: [["key": "hero", "value": "A"] as [String: Any]]
         )
-        XCTAssertEqual(a, b, "States with identical dictionary contents in different insertion order must be equal")
+        XCTAssertEqual(a, b, "States with identical profile contents in different key order must be equal")
     }
 
     func testOptimizationStateInequality() {
@@ -1116,4 +1141,107 @@ final class OptimizationClientTests: XCTestCase {
         manager.destroy()
         XCTAssertNil(manager.context)
     }
+
+    // MARK: - anonymousId persistence
+
+    private func readStoredAnonymousId() -> String? {
+        let suite = UserDefaults(suiteName: "com.contentful.optimization") ?? .standard
+        guard let data = suite.data(forKey: "com.contentful.optimization.anonymousId") else {
+            return nil
+        }
+        return String(data: data, encoding: .utf8)
+    }
+
+    @MainActor
+    func testAnonymousIdPersistedOnProfileUpdate() async throws {
+        let client = OptimizationClient()
+        defer { client.destroy() }
+
+        try client.initialize(config: OptimizationConfig(
+            clientId: "test-client",
+            environment: "master",
+            experienceBaseUrl: "http://localhost:8000/experience/",
+            insightsBaseUrl: "http://localhost:8000/insights/",
+            defaults: StorageDefaults(profile: [
+                "id": "abc-123", "stableId": "sid", "random": "r"
+            ])
+        ))
+
+        try await Task.sleep(nanoseconds: 200_000_000)
+
+        XCTAssertEqual(readStoredAnonymousId(), "abc-123",
+                       "Profile.id must be written through to stored anonymousId")
+    }
+
+    @MainActor
+    func testAnonymousIdPreservedWhenNewProfileHasNoId() async throws {
+        let client = OptimizationClient()
+        defer { client.destroy() }
+
+        try client.initialize(config: OptimizationConfig(
+            clientId: "test-client",
+            environment: "master",
+            experienceBaseUrl: "http://localhost:8000/experience/",
+            insightsBaseUrl: "http://localhost:8000/insights/",
+            defaults: StorageDefaults(profile: [
+                "id": "first-id", "stableId": "sid", "random": "r"
+            ])
+        ))
+        try await Task.sleep(nanoseconds: 200_000_000)
+        XCTAssertEqual(readStoredAnonymousId(), "first-id")
+
+        client.testOnlyEvaluateScript("""
+            __bridge.destroy();
+            __bridge.initialize({
+                clientId: "test-client",
+                environment: "master",
+                experienceBaseUrl: "http://localhost:8000/experience/",
+                insightsBaseUrl: "http://localhost:8000/insights/",
+                defaults: {
+                    profile: { stableId: "sid", random: "r" }
+                }
+            });
+        """)
+        try await Task.sleep(nanoseconds: 200_000_000)
+
+        XCTAssertEqual(readStoredAnonymousId(), "first-id",
+                       "Previously-stored anonymousId must be preserved when new profile omits id")
+    }
+
+    // MARK: - changes array
+
+    @MainActor
+    func testChangesPopulatesAsArrayFromBridge() async throws {
+        let client = OptimizationClient()
+        defer { client.destroy() }
+
+        try client.initialize(config: OptimizationConfig(
+            clientId: "test-client",
+            environment: "master",
+            experienceBaseUrl: "http://localhost:8000/experience/",
+            insightsBaseUrl: "http://localhost:8000/insights/"
+        ))
+
+        client.testOnlyEvaluateScript("""
+            __bridge.destroy();
+            __bridge.initialize({
+                clientId: "test-client",
+                environment: "master",
+                experienceBaseUrl: "http://localhost:8000/experience/",
+                insightsBaseUrl: "http://localhost:8000/insights/",
+                defaults: {
+                    changes: [
+                        { key: "hero.title", type: "Variable", meta: { experienceId: "exp-1", variantIndex: 1 }, value: "Hello" }
+                    ]
+                }
+            });
+        """)
+
+        try await Task.sleep(nanoseconds: 200_000_000)
+
+        XCTAssertNotNil(client.state.changes,
+                        "state.changes must populate when bridge emits a ChangeArray")
+        XCTAssertEqual(client.state.changes?.count, 1)
+        XCTAssertEqual(client.state.changes?.first?["key"] as? String, "hero.title")
+    }
 }
diff --git a/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/PreviewModelTests.swift b/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/PreviewModelTests.swift
new file mode 100644
index 00000000..85efb2d0
--- /dev/null
+++ b/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/PreviewModelTests.swift
@@ -0,0 +1,174 @@
+import XCTest
+@testable import ContentfulOptimization
+
+/// Tests for the pre-baked preview model served by the JS bridge. Verifies
+/// the Swift `PreviewModelDTO` decoder sees what core's `buildPreviewModel`
+/// produces — and that `loadDefinitions` successfully hands entries across
+/// the bridge boundary.
+final class PreviewModelTests: XCTestCase {
+
+    @MainActor
+    private func makeInitializedClient() throws -> OptimizationClient {
+        let client = OptimizationClient()
+        let config = OptimizationConfig(
+            clientId: "test-client",
+            environment: "master",
+            experienceBaseUrl: "http://localhost:8000/experience/",
+            insightsBaseUrl: "http://localhost:8000/insights/"
+        )
+        try client.initialize(config: config)
+        return client
+    }
+
+    private func audienceEntry(id: String, name: String) -> [String: Any] {
+        [
+            "sys": ["id": "sys-\(id)"],
+            "fields": ["nt_audience_id": id, "nt_name": name],
+        ]
+    }
+
+    private func experienceEntry(id: String, name: String, audienceId: String?) -> [String: Any] {
+        var fields: [String: Any] = [
+            "nt_experience_id": id,
+            "nt_name": name,
+        ]
+        if let audienceId = audienceId {
+            fields["nt_audience"] = ["sys": ["id": audienceId]]
+        }
+        return ["sys": ["id": "sys-\(id)"], "fields": fields]
+    }
+
+    @MainActor
+    func testPreviewModelIsNullBeforeLoadDefinitions() throws {
+        let client = try makeInitializedClient()
+        let state = client.getPreviewState()
+        XCTAssertNotNil(state)
+        XCTAssertNil(state?.previewModel,
+                     "previewModel must be nil until the host calls loadDefinitions()")
+    }
+
+    @MainActor
+    func testLoadDefinitionsPopulatesPreviewModel() throws {
+        let client = try makeInitializedClient()
+
+        try client.loadDefinitions(
+            audiences: [audienceEntry(id: "aud-1", name: "Audience One")],
+            experiences: [
+                experienceEntry(id: "exp-1", name: "Experience One", audienceId: "aud-1"),
+            ]
+        )
+
+        let state = client.getPreviewState()
+        XCTAssertNotNil(state?.previewModel, "previewModel must be populated after loadDefinitions()")
+        let model = state?.previewModel
+
+        XCTAssertEqual(model?.hasData, true)
+        XCTAssertEqual(model?.audienceNameMap["aud-1"], "Audience One")
+        XCTAssertEqual(model?.experienceNameMap["exp-1"], "Experience One")
+        XCTAssertEqual(model?.audiencesWithExperiences.count, 1)
+
+        let aud = model?.audiencesWithExperiences.first
+        XCTAssertEqual(aud?.audience.id, "aud-1")
+        XCTAssertEqual(aud?.isQualified, false)
+        XCTAssertEqual(aud?.isActive, false)
+        XCTAssertEqual(aud?.overrideState, "default")
+        XCTAssertEqual(aud?.experiences.count, 1)
+        XCTAssertEqual(aud?.experiences.first?.id, "exp-1")
+    }
+
+    @MainActor
+    func testPreviewModelReflectsAudienceOverrides() throws {
+        let client = try makeInitializedClient()
+
+        try client.loadDefinitions(
+            audiences: [audienceEntry(id: "aud-1", name: "Audience One")],
+            experiences: [
+                experienceEntry(id: "exp-1", name: "Experience One", audienceId: "aud-1"),
+            ]
+        )
+
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: ["exp-1"])
+
+        let state = client.getPreviewState()
+        let aud = state?.previewModel?.audiencesWithExperiences.first
+        XCTAssertEqual(aud?.overrideState, "on")
+        XCTAssertEqual(aud?.isActive, true)
+    }
+
+    /// Seed the JS bridge `selectedOptimizations` signal with a known natural
+    /// baseline so the preview override manager captures it. Mirrors the
+    /// pattern used by `PreviewOverrideTests.seedSignals` — just the subset
+    /// this test needs.
+    @MainActor
+    private func seedSelectedOptimization(client: OptimizationClient, experienceId: String, variantIndex: Int) {
+        client.testOnlyEvaluateScript("""
+            __bridge.destroy();
+            __bridge.initialize({
+                clientId: "test-client",
+                environment: "master",
+                experienceBaseUrl: "http://localhost:8000/experience/",
+                insightsBaseUrl: "http://localhost:8000/insights/",
+                defaults: {
+                    optimizations: [
+                        {"experienceId":"\(experienceId)","variantIndex":\(variantIndex)}
+                    ]
+                }
+            });
+        """)
+    }
+
+    @MainActor
+    func testExperienceDTOCarriesCurrentVariantAndOverrideFlag() throws {
+        let client = try makeInitializedClient()
+        seedSelectedOptimization(client: client, experienceId: "exp-1", variantIndex: 0)
+
+        try client.loadDefinitions(
+            audiences: [audienceEntry(id: "aud-1", name: "Audience One")],
+            experiences: [
+                experienceEntry(id: "exp-1", name: "Experience One", audienceId: "aud-1"),
+            ]
+        )
+
+        // Before override: defaults should surface as currentVariantIndex = 0,
+        // isOverridden = false, and naturalVariantIndex not populated.
+        let before = client.getPreviewState()
+        let expBefore = before?.previewModel?.audiencesWithExperiences.first?.experiences.first
+        XCTAssertEqual(expBefore?.currentVariantIndex, 0)
+        XCTAssertEqual(expBefore?.isOverridden, false)
+        XCTAssertNil(expBefore?.naturalVariantIndex)
+
+        // Apply a variant override and re-read.
+        client.overrideVariant(experienceId: "exp-1", variantIndex: 2)
+
+        let after = client.getPreviewState()
+        let expAfter = after?.previewModel?.audiencesWithExperiences.first?.experiences.first
+        XCTAssertEqual(expAfter?.currentVariantIndex, 2,
+                       "currentVariantIndex should reflect the applied override")
+        XCTAssertEqual(expAfter?.isOverridden, true)
+        XCTAssertEqual(expAfter?.naturalVariantIndex, 0,
+                       "naturalVariantIndex should fall back to the baseline's 0")
+    }
+
+    @MainActor
+    func testAllVisitorsBucketAppearsForUnassociatedExperiences() throws {
+        let client = try makeInitializedClient()
+
+        try client.loadDefinitions(
+            audiences: [],
+            experiences: [
+                experienceEntry(id: "exp-global", name: "Global Experience", audienceId: nil),
+            ]
+        )
+
+        let state = client.getPreviewState()
+        let model = state?.previewModel
+        XCTAssertEqual(model?.audiencesWithExperiences.count, 1)
+
+        let bucket = model?.audiencesWithExperiences.first
+        XCTAssertEqual(bucket?.audience.id, "ALL_VISITORS")
+        XCTAssertEqual(bucket?.isQualified, true)
+        XCTAssertEqual(bucket?.isActive, true)
+        XCTAssertEqual(bucket?.experiences.first?.id, "exp-global")
+        XCTAssertEqual(model?.unassociatedExperiences.map(\.id), ["exp-global"])
+    }
+}
diff --git a/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/PreviewOverrideTests.swift b/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/PreviewOverrideTests.swift
index 0cd9a049..70c45da4 100644
--- a/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/PreviewOverrideTests.swift
+++ b/packages/ios/ContentfulOptimization/Tests/ContentfulOptimizationTests/PreviewOverrideTests.swift
@@ -1,3 +1,4 @@
+import Combine
 import XCTest
 @testable import ContentfulOptimization
 
@@ -25,19 +26,43 @@ final class PreviewOverrideTests: XCTestCase {
         return client
     }
 
-    /// Seed the JS bridge signals with audience changes and selected optimizations.
+    /// Seed the JS bridge signals with the qualifying audiences and selected
+    /// optimizations the tests need. Audience qualification is carried in
+    /// `profile.audiences` — the canonical location per the Experience API
+    /// schema — not in the `changes` signal (which is reserved for Custom Flag
+    /// `VariableChange` entries).
     @MainActor
     private func seedSignals(
         client: OptimizationClient,
         audiences: [(id: String, qualified: Bool)],
         experiences: [(id: String, variantIndex: Int)]
     ) {
-        let changesJSON = audiences.map { audience in
-            """
-            {"audienceId":"\(audience.id)","qualified":\(audience.qualified),"name":"Audience \(audience.id)"}
-            """
-        }.joined(separator: ",")
-        let changesScript = "[\(changesJSON)]"
+        let qualifiedAudienceIds = audiences.filter(\.qualified).map(\.id)
+        let audiencesJSON = qualifiedAudienceIds.map { "\"\($0)\"" }.joined(separator: ",")
+        let profileScript = """
+            {
+                "id": "test-profile",
+                "stableId": "test-profile",
+                "random": 0,
+                "audiences": [\(audiencesJSON)],
+                "traits": {},
+                "location": {},
+                "session": {
+                    "id": "test-session",
+                    "isReturningVisitor": false,
+                    "count": 1,
+                    "activeSessionLength": 0,
+                    "averageSessionLength": 0,
+                    "landingPage": {
+                        "url": "",
+                        "referrer": "",
+                        "query": {},
+                        "search": "",
+                        "path": ""
+                    }
+                }
+            }
+        """
 
         let experiencesJSON = experiences.map { exp in
             """
@@ -54,7 +79,7 @@ final class PreviewOverrideTests: XCTestCase {
                 experienceBaseUrl: "http://localhost:8000/experience/",
                 insightsBaseUrl: "http://localhost:8000/insights/",
                 defaults: {
-                    changes: \(changesScript),
+                    profile: \(profileScript),
                     optimizations: [\(experiencesJSON)]
                 }
             });
@@ -87,7 +112,7 @@ final class PreviewOverrideTests: XCTestCase {
         )
 
         // Override aud-1 to qualified
-        client.overrideAudience(id: "aud-1", qualified: true)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
 
         let state = client.getPreviewState()
         XCTAssertNotNil(state)
@@ -106,7 +131,7 @@ final class PreviewOverrideTests: XCTestCase {
             experiences: []
         )
 
-        client.overrideAudience(id: "aud-1", qualified: false)
+        client.overrideAudience(id: "aud-1", qualified: false, experienceIds: [])
 
         let state = client.getPreviewState()
         XCTAssertEqual(state?.audienceOverrides?["aud-1"], false)
@@ -123,8 +148,8 @@ final class PreviewOverrideTests: XCTestCase {
             experiences: []
         )
 
-        client.overrideAudience(id: "aud-1", qualified: true)
-        client.overrideAudience(id: "aud-2", qualified: false)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
+        client.overrideAudience(id: "aud-2", qualified: false, experienceIds: [])
 
         let state = client.getPreviewState()
         XCTAssertEqual(state?.audienceOverrides?.count, 2)
@@ -184,7 +209,7 @@ final class PreviewOverrideTests: XCTestCase {
             experiences: [("exp-1", 0)]
         )
 
-        client.overrideAudience(id: "aud-1", qualified: true)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
         client.overrideVariant(experienceId: "exp-1", variantIndex: 2)
 
         // First read (panel open)
@@ -215,8 +240,8 @@ final class PreviewOverrideTests: XCTestCase {
             experiences: []
         )
 
-        client.overrideAudience(id: "aud-1", qualified: true)
-        client.overrideAudience(id: "aud-2", qualified: false)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
+        client.overrideAudience(id: "aud-2", qualified: false, experienceIds: [])
 
         // Reset only aud-1
         client.resetAudienceOverride(id: "aud-1")
@@ -226,12 +251,10 @@ final class PreviewOverrideTests: XCTestCase {
                      "Reset audience should be removed from overrides")
         XCTAssertEqual(state?.audienceOverrides?["aud-2"], false,
                        "Other overrides should remain")
-
-        // Verify the signal was restored to the default value
-        let changes = state?.changes ?? []
-        let aud1Change = changes.first(where: { $0.audienceId == "aud-1" })
-        XCTAssertEqual(aud1Change?.qualified, false,
-                       "Signal should be restored to original qualified=false")
+        XCTAssertNil(state?.defaultAudienceQualifications?["aud-1"],
+                     "Default snapshot for reset audience should be cleared")
+        XCTAssertEqual(state?.defaultAudienceQualifications?["aud-2"], true,
+                       "Default snapshot for remaining override should persist")
     }
 
     // MARK: - Reset single variant override
@@ -275,8 +298,8 @@ final class PreviewOverrideTests: XCTestCase {
             experiences: [("exp-1", 0), ("exp-2", 1)]
         )
 
-        client.overrideAudience(id: "aud-1", qualified: true)
-        client.overrideAudience(id: "aud-2", qualified: false)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
+        client.overrideAudience(id: "aud-2", qualified: false, experienceIds: [])
         client.overrideVariant(experienceId: "exp-1", variantIndex: 2)
         client.overrideVariant(experienceId: "exp-2", variantIndex: 0)
 
@@ -298,13 +321,9 @@ final class PreviewOverrideTests: XCTestCase {
         XCTAssertEqual(after?.defaultVariantIndices ?? [:], [:],
                        "Default snapshots should be cleared")
 
-        // Verify signals were restored to defaults
-        let changes = after?.changes ?? []
-        let aud1 = changes.first(where: { $0.audienceId == "aud-1" })
-        let aud2 = changes.first(where: { $0.audienceId == "aud-2" })
-        XCTAssertEqual(aud1?.qualified, false, "aud-1 should be restored to original false")
-        XCTAssertEqual(aud2?.qualified, true, "aud-2 should be restored to original true")
-
+        // Verify the variant signal was restored to defaults. (The audience
+        // qualification signal — `profile.audiences` — is not rewritten by
+        // overrides today; see the plan notes.)
         let personalizations = after?.selectedPersonalizations ?? []
         let exp1 = personalizations.first(where: { $0.experienceId == "exp-1" })
         let exp2 = personalizations.first(where: { $0.experienceId == "exp-2" })
@@ -324,12 +343,12 @@ final class PreviewOverrideTests: XCTestCase {
         )
 
         // First override captures default=false
-        client.overrideAudience(id: "aud-1", qualified: true)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
         let state1 = client.getPreviewState()
         XCTAssertEqual(state1?.defaultAudienceQualifications?["aud-1"], false)
 
         // Second override should NOT update the default
-        client.overrideAudience(id: "aud-1", qualified: false)
+        client.overrideAudience(id: "aud-1", qualified: false, experienceIds: [])
         let state2 = client.getPreviewState()
         XCTAssertEqual(state2?.defaultAudienceQualifications?["aud-1"], false,
                        "Default should still be the original value, not the first override")
@@ -372,7 +391,7 @@ final class PreviewOverrideTests: XCTestCase {
 
         // Simulate: panel opens, user sets overrides
         client.setPreviewPanelOpen(true)
-        client.overrideAudience(id: "aud-1", qualified: true)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
         client.overrideVariant(experienceId: "exp-1", variantIndex: 1)
 
         // Simulate: panel closes
@@ -403,7 +422,7 @@ final class PreviewOverrideTests: XCTestCase {
             experiences: [("exp-1", 0)]
         )
 
-        client.overrideAudience(id: "aud-1", qualified: true)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
         client.overrideVariant(experienceId: "exp-1", variantIndex: 2)
 
         // Destroy and reinitialize
@@ -434,7 +453,7 @@ final class PreviewOverrideTests: XCTestCase {
             experiences: [("exp-1", 0)]
         )
 
-        client.overrideAudience(id: "aud-1", qualified: true)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
         client.overrideVariant(experienceId: "exp-1", variantIndex: 2)
 
         // SDK reset
@@ -449,23 +468,6 @@ final class PreviewOverrideTests: XCTestCase {
 
     // MARK: - Override changes are reflected in the signals
 
-    @MainActor
-    func testAudienceOverrideModifiesChangesSignal() throws {
-        let client = try makeInitializedClient()
-        seedSignals(
-            client: client,
-            audiences: [("aud-1", false)],
-            experiences: []
-        )
-
-        client.overrideAudience(id: "aud-1", qualified: true)
-
-        let state = client.getPreviewState()
-        let change = state?.changes?.first(where: { $0.audienceId == "aud-1" })
-        XCTAssertEqual(change?.qualified, true,
-                       "The changes signal should reflect the override")
-    }
-
     @MainActor
     func testVariantOverrideModifiesPersonalizationsSignal() throws {
         let client = try makeInitializedClient()
@@ -499,9 +501,8 @@ final class PreviewOverrideTests: XCTestCase {
 
         let state = client.getPreviewState()
         XCTAssertEqual(state?.audienceOverrides ?? [:], [:])
-        // Changes should remain unchanged
-        let change = state?.changes?.first(where: { $0.audienceId == "aud-1" })
-        XCTAssertEqual(change?.qualified, false)
+        XCTAssertEqual(state?.defaultAudienceQualifications ?? [:], [:],
+                       "No-op reset should not produce a baseline snapshot")
     }
 
     @MainActor
@@ -532,14 +533,14 @@ final class PreviewOverrideTests: XCTestCase {
         )
 
         // Override
-        client.overrideAudience(id: "aud-1", qualified: true)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
         client.overrideVariant(experienceId: "exp-1", variantIndex: 2)
 
         // Reset all
         client.resetAllOverrides()
 
         // Override again with different values
-        client.overrideAudience(id: "aud-1", qualified: true)
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: [])
         client.overrideVariant(experienceId: "exp-1", variantIndex: 3)
 
         let state = client.getPreviewState()
@@ -551,4 +552,67 @@ final class PreviewOverrideTests: XCTestCase {
         XCTAssertEqual(state?.defaultVariantIndices?["exp-1"], 0,
                        "Default should be the natural value after reset")
     }
+
+    // MARK: - onOverridesChanged push callback
+
+    @MainActor
+    func testOverrideActionPushesPreviewStateViaPublisher() async throws {
+        let client = try makeInitializedClient()
+        defer { client.destroy() }
+
+        seedSignals(
+            client: client,
+            audiences: [("aud-1", false)],
+            experiences: [("exp-1", 0)]
+        )
+
+        var emissions: [PreviewState] = []
+        let emissionReceived = expectation(description: "previewState publisher emits after override")
+        emissionReceived.expectedFulfillmentCount = 1
+        emissionReceived.assertForOverFulfill = false
+
+        let cancellable = client.$previewState
+            .compactMap { $0 }
+            .sink { state in
+                emissions.append(state)
+                emissionReceived.fulfill()
+            }
+
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: ["exp-1"])
+
+        await fulfillment(of: [emissionReceived], timeout: 2)
+        cancellable.cancel()
+
+        XCTAssertFalse(emissions.isEmpty,
+                       "Publisher must emit after overrideAudience; push path, not polling")
+        XCTAssertEqual(emissions.last?.audienceOverrides?["aud-1"], true,
+                       "Pushed PreviewState must reflect the applied override")
+    }
+
+    @MainActor
+    func testMultipleOverrideActionsEachPushPreviewState() async throws {
+        let client = try makeInitializedClient()
+        defer { client.destroy() }
+
+        seedSignals(
+            client: client,
+            audiences: [("aud-1", false)],
+            experiences: [("exp-1", 0)]
+        )
+
+        let emissionReceived = expectation(description: "publisher emits per override action")
+        emissionReceived.expectedFulfillmentCount = 3
+        emissionReceived.assertForOverFulfill = false
+
+        let cancellable = client.$previewState
+            .compactMap { $0 }
+            .sink { _ in emissionReceived.fulfill() }
+
+        client.overrideAudience(id: "aud-1", qualified: true, experienceIds: ["exp-1"])
+        client.overrideVariant(experienceId: "exp-1", variantIndex: 2)
+        client.resetAllOverrides()
+
+        await fulfillment(of: [emissionReceived], timeout: 2)
+        cancellable.cancel()
+    }
 }
diff --git a/packages/ios/ios-jsc-bridge/src/index.ts b/packages/ios/ios-jsc-bridge/src/index.ts
index d61583f2..4a4f20a4 100644
--- a/packages/ios/ios-jsc-bridge/src/index.ts
+++ b/packages/ios/ios-jsc-bridge/src/index.ts
@@ -5,6 +5,16 @@ import {
   effect,
   signals,
 } from '@contentful/optimization-core'
+import {
+  type AudienceDefinition,
+  type ContentfulEntry,
+  type ExperienceDefinition,
+  PreviewOverrideManager,
+  buildPreviewModel,
+  createAudienceDefinitions,
+  createExperienceDefinitions,
+  createExperienceNameMap,
+} from '@contentful/optimization-core/preview-support'
 
 type ResolveOptimizedEntryParams = Parameters<CoreStateful['resolveOptimizedEntry']>
 
@@ -89,46 +99,23 @@ interface Bridge {
 
   // Preview panel
   setPreviewPanelOpen(open: boolean): void
-  overrideAudience(audienceId: string, qualified: boolean): void
+  overrideAudience(audienceId: string, qualified: boolean, experienceIds: string[]): void
   overrideVariant(experienceId: string, variantIndex: number): void
   resetAudienceOverride(audienceId: string): void
   resetVariantOverride(experienceId: string): void
   resetAllOverrides(): void
+  loadDefinitions(audienceEntries: unknown[], experienceEntries: unknown[]): string
   getPreviewState(): string
 }
 
 let instance: CoreStateful | null = null
 let disposeEffect: (() => void) | null = null
 let disposeEventEffect: (() => void) | null = null
-
-// Override tracking: stores the natural (pre-override) values and active override maps
-const defaultAudienceQualifications = new Map<string, boolean>()
-const defaultVariantIndices = new Map<string, number>()
-const audienceOverrides = new Map<string, boolean>()
-const variantOverrides = new Map<string, number>()
-
-function snapshotAudienceDefault(audienceId: string) {
-  if (defaultAudienceQualifications.has(audienceId)) return
-  const changes = (signals.changes.value ?? []) as Array<Record<string, unknown>>
-  const change = changes.find((c) => c.audienceId === audienceId)
-  defaultAudienceQualifications.set(audienceId, (change?.qualified as boolean) ?? false)
-}
-
-function snapshotVariantDefault(experienceId: string) {
-  if (defaultVariantIndices.has(experienceId)) return
-  const optimizations = (signals.selectedOptimizations.value ?? []) as Array<
-    Record<string, unknown>
-  >
-  const opt = optimizations.find((p) => p.experienceId === experienceId)
-  defaultVariantIndices.set(experienceId, (opt?.variantIndex as number) ?? 0)
-}
-
-function clearOverrideTracking() {
-  defaultAudienceQualifications.clear()
-  defaultVariantIndices.clear()
-  audienceOverrides.clear()
-  variantOverrides.clear()
-}
+let overrideManager: PreviewOverrideManager | null = null
+let audienceDefinitions: AudienceDefinition[] | null = null
+let experienceDefinitions: ExperienceDefinition[] | null = null
+let audienceNameMap: Record<string, string> = {}
+let experienceNameMap: Record<string, string> = {}
 
 const bridge: Bridge = {
   initialize(config: BridgeConfig) {
@@ -136,6 +123,11 @@ const bridge: Bridge = {
       bridge.destroy()
     }
 
+    audienceDefinitions = null
+    experienceDefinitions = null
+    audienceNameMap = {}
+    experienceNameMap = {}
+
     const coreConfig: CoreStatefulConfig = {
       clientId: config.clientId,
       environment: config.environment,
@@ -165,8 +157,22 @@ const bridge: Bridge = {
     }
     instance.consent(true)
 
+    // Create the override manager — registers a state interceptor that
+    // preserves overrides across API refreshes and correctly appends
+    // new experience entries when overriding audiences the user was never in.
     const g = globalThis as Record<string, unknown>
 
+    overrideManager = new PreviewOverrideManager({
+      selectedOptimizations: signals.selectedOptimizations,
+      profile: signals.profile,
+      stateInterceptors: instance.interceptors.state,
+      onOverridesChanged: () => {
+        if (typeof g.__nativeOnOverridesChanged === 'function') {
+          ;(g.__nativeOnOverridesChanged as (json: string) => void)(bridge.getPreviewState())
+        }
+      },
+    })
+
     disposeEffect = effect(() => {
       const state: BridgeState = {
         profile: signals.profile.value ?? null,
@@ -295,7 +301,7 @@ const bridge: Bridge = {
 
   reset() {
     if (!instance) return
-    clearOverrideTracking()
+    overrideManager?.resetAll()
     instance.reset()
   },
 
@@ -320,125 +326,109 @@ const bridge: Bridge = {
     signals.previewPanelOpen.value = open
   },
 
-  overrideAudience(audienceId: string, qualified: boolean) {
-    if (!instance) return
-    snapshotAudienceDefault(audienceId)
-    audienceOverrides.set(audienceId, qualified)
-
-    const currentChanges = (signals.changes.value ?? []) as Array<Record<string, unknown>>
-    const updatedChanges = currentChanges.map((change) => {
-      if (change.audienceId === audienceId) {
-        return { ...change, qualified }
-      }
-      return change
-    })
-    signals.changes.value = updatedChanges as typeof signals.changes.value
+  overrideAudience(audienceId: string, qualified: boolean, experienceIds: string[]) {
+    if (!overrideManager) return
+    if (qualified) {
+      overrideManager.activateAudience(audienceId, experienceIds)
+    } else {
+      overrideManager.deactivateAudience(audienceId, experienceIds)
+    }
   },
 
   overrideVariant(experienceId: string, variantIndex: number) {
-    if (!instance) return
-    snapshotVariantDefault(experienceId)
-    variantOverrides.set(experienceId, variantIndex)
-
-    const currentPersonalizations = (signals.selectedOptimizations.value ?? []) as Array<
-      Record<string, unknown>
-    >
-    const updatedPersonalizations = currentPersonalizations.map((p) => {
-      if (p.experienceId === experienceId) {
-        return { ...p, variantIndex }
-      }
-      return p
-    })
-    signals.selectedOptimizations.value =
-      updatedPersonalizations as typeof signals.selectedOptimizations.value
+    overrideManager?.setVariantOverride(experienceId, variantIndex)
   },
 
   resetAudienceOverride(audienceId: string) {
-    if (!instance) return
-    const defaultQualified = defaultAudienceQualifications.get(audienceId)
-    if (defaultQualified === undefined) return
-
-    audienceOverrides.delete(audienceId)
-
-    const currentChanges = (signals.changes.value ?? []) as Array<Record<string, unknown>>
-    const updatedChanges = currentChanges.map((change) => {
-      if (change.audienceId === audienceId) {
-        return { ...change, qualified: defaultQualified }
-      }
-      return change
-    })
-    signals.changes.value = updatedChanges as typeof signals.changes.value
+    overrideManager?.resetAudienceOverride(audienceId)
   },
 
   resetVariantOverride(experienceId: string) {
-    if (!instance) return
-    const defaultVariant = defaultVariantIndices.get(experienceId)
-    if (defaultVariant === undefined) return
-
-    variantOverrides.delete(experienceId)
-
-    const currentPersonalizations = (signals.selectedOptimizations.value ?? []) as Array<
-      Record<string, unknown>
-    >
-    const updatedPersonalizations = currentPersonalizations.map((p) => {
-      if (p.experienceId === experienceId) {
-        return { ...p, variantIndex: defaultVariant }
-      }
-      return p
-    })
-    signals.selectedOptimizations.value =
-      updatedPersonalizations as typeof signals.selectedOptimizations.value
+    overrideManager?.resetOptimizationOverride(experienceId)
   },
 
   resetAllOverrides() {
-    if (!instance) return
+    overrideManager?.resetAll()
+  },
 
-    // Restore all audience defaults
-    const currentChanges = (signals.changes.value ?? []) as Array<Record<string, unknown>>
-    const restoredChanges = currentChanges.map((change) => {
-      const audienceId = change.audienceId as string | undefined
-      if (audienceId && defaultAudienceQualifications.has(audienceId)) {
-        return { ...change, qualified: defaultAudienceQualifications.get(audienceId) }
+  loadDefinitions(audienceEntries: unknown[], experienceEntries: unknown[]): string {
+    try {
+      const audEntries = audienceEntries as ContentfulEntry[]
+      const expEntries = experienceEntries as ContentfulEntry[]
+
+      audienceDefinitions = createAudienceDefinitions(audEntries)
+      experienceDefinitions = createExperienceDefinitions(expEntries)
+      experienceNameMap = createExperienceNameMap(expEntries)
+      audienceNameMap = {}
+      for (const def of audienceDefinitions) {
+        audienceNameMap[def.id] = def.name
       }
-      return change
-    })
-    signals.changes.value = restoredChanges as typeof signals.changes.value
-
-    // Restore all variant defaults
-    const currentPersonalizations = (signals.selectedOptimizations.value ?? []) as Array<
-      Record<string, unknown>
-    >
-    const restoredPersonalizations = currentPersonalizations.map((p) => {
-      const experienceId = p.experienceId as string | undefined
-      if (experienceId && defaultVariantIndices.has(experienceId)) {
-        return { ...p, variantIndex: defaultVariantIndices.get(experienceId) }
-      }
-      return p
-    })
-    signals.selectedOptimizations.value =
-      restoredPersonalizations as typeof signals.selectedOptimizations.value
 
-    clearOverrideTracking()
+      return JSON.stringify({
+        audienceCount: audienceDefinitions.length,
+        experienceCount: experienceDefinitions.length,
+      })
+    } catch (err: unknown) {
+      audienceDefinitions = null
+      experienceDefinitions = null
+      audienceNameMap = {}
+      experienceNameMap = {}
+      return JSON.stringify({
+        error: err instanceof Error ? err.message : String(err),
+      })
+    }
   },
 
   getPreviewState(): string {
-    // Convert override maps to plain objects for JSON serialization
-    const audOverrides: Record<string, boolean> = {}
-    audienceOverrides.forEach((v, k) => {
-      audOverrides[k] = v
-    })
-    const varOverrides: Record<string, number> = {}
-    variantOverrides.forEach((v, k) => {
-      varOverrides[k] = v
-    })
-    const audDefaults: Record<string, boolean> = {}
-    defaultAudienceQualifications.forEach((v, k) => {
-      audDefaults[k] = v
-    })
-    const varDefaults: Record<string, number> = {}
-    defaultVariantIndices.forEach((v, k) => {
-      varDefaults[k] = v
-    })
+    const overrides = overrideManager?.getOverrides() ?? {
+      audiences: {},
+      selectedOptimizations: {},
+    }
+    const baselineOptimizations = overrideManager?.getBaselineSelectedOptimizations()
+
+    // Transform audience overrides to the shape Swift expects: Record<string, boolean>
+    const audienceOverrides: Record<string, boolean> = {}
+    for (const [id, aud] of Object.entries(overrides.audiences)) {
+      audienceOverrides[id] = aud.isActive
+    }
+
+    // Transform variant overrides to the shape Swift expects: Record<string, number>
+    const variantOverrides: Record<string, number> = {}
+    for (const [id, opt] of Object.entries(overrides.selectedOptimizations)) {
+      variantOverrides[id] = opt.variantIndex
+    }
+
+    // Derive default variant indices from the baseline
+    const defaultVariantIndices: Record<string, number> = {}
+    if (baselineOptimizations) {
+      for (const sel of baselineOptimizations) {
+        if (variantOverrides[sel.experienceId] !== undefined) {
+          defaultVariantIndices[sel.experienceId] = sel.variantIndex
+        }
+      }
+    }
+
+    // Compute the pre-baked UI model when definitions have been loaded by the host.
+    // Null when loadDefinitions() has not yet been called — iOS renders an empty state.
+    const previewModel =
+      audienceDefinitions && experienceDefinitions
+        ? {
+            ...buildPreviewModel({
+              audienceDefinitions,
+              experienceDefinitions,
+              signals: {
+                profile: signals.profile.value,
+                selectedOptimizations: signals.selectedOptimizations.value,
+                consent: signals.consent.value,
+                isLoading: false,
+              },
+              overrides,
+              baselineSelectedOptimizations: baselineOptimizations,
+            }),
+            audienceNameMap,
+            experienceNameMap,
+          }
+        : null
 
     return JSON.stringify({
       profile: signals.profile.value ?? null,
@@ -447,10 +437,11 @@ const bridge: Bridge = {
       changes: signals.changes.value ?? null,
       selectedPersonalizations: signals.selectedOptimizations.value ?? null,
       previewPanelOpen: signals.previewPanelOpen.value,
-      audienceOverrides: audOverrides,
-      variantOverrides: varOverrides,
-      defaultAudienceQualifications: audDefaults,
-      defaultVariantIndices: varDefaults,
+      audienceOverrides,
+      variantOverrides,
+      defaultAudienceQualifications: overrideManager?.getBaselineAudienceQualifications() ?? {},
+      defaultVariantIndices,
+      previewModel,
     })
   },
 
@@ -471,7 +462,12 @@ const bridge: Bridge = {
   },
 
   destroy() {
-    clearOverrideTracking()
+    overrideManager?.destroy()
+    overrideManager = null
+    audienceDefinitions = null
+    experienceDefinitions = null
+    audienceNameMap = {}
+    experienceNameMap = {}
     if (disposeEventEffect) {
       disposeEventEffect()
       disposeEventEffect = null
diff --git a/packages/react-native-sdk/dev/metro.config.js b/packages/react-native-sdk/dev/metro.config.js
index a26d4b69..f7fa8f12 100644
--- a/packages/react-native-sdk/dev/metro.config.js
+++ b/packages/react-native-sdk/dev/metro.config.js
@@ -31,6 +31,10 @@ const config = {
           workspaceRoot,
           'packages/universal/core-sdk/src/index.ts',
         ),
+        '@contentful/optimization-core/preview-support': path.resolve(
+          workspaceRoot,
+          'packages/universal/core-sdk/src/preview-support/index.ts',
+        ),
         '@contentful/optimization-api-client': path.resolve(
           workspaceRoot,
           'packages/universal/api-client/src/index.ts',
diff --git a/packages/react-native-sdk/package.json b/packages/react-native-sdk/package.json
index 2ee02522..90007930 100644
--- a/packages/react-native-sdk/package.json
+++ b/packages/react-native-sdk/package.json
@@ -97,6 +97,20 @@
         "default": "./dist/api-schemas.cjs"
       }
     },
+    "./preview-support": {
+      "react-native": {
+        "types": "./dist/preview-support.d.mts",
+        "default": "./dist/preview-support.mjs"
+      },
+      "import": {
+        "types": "./dist/preview-support.d.mts",
+        "default": "./dist/preview-support.mjs"
+      },
+      "require": {
+        "types": "./dist/preview-support.d.cts",
+        "default": "./dist/preview-support.cjs"
+      }
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -106,7 +120,9 @@
     "bundleSize": {
       "gzipBudgets": {
         "index.cjs": 27000,
-        "index.mjs": 25500
+        "index.mjs": 25500,
+        "preview-support.cjs": 6500,
+        "preview-support.mjs": 5500
       }
     }
   },
diff --git a/packages/react-native-sdk/rslib.config.ts b/packages/react-native-sdk/rslib.config.ts
index ddb3e4c6..8707542f 100644
--- a/packages/react-native-sdk/rslib.config.ts
+++ b/packages/react-native-sdk/rslib.config.ts
@@ -26,6 +26,7 @@ export default defineConfig({
       'core-sdk': './src/core-sdk.ts',
       'api-client': './src/api-client.ts',
       'api-schemas': './src/api-schemas.ts',
+      'preview-support': './src/preview-support.ts',
     },
     tsconfigPath: './tsconfig.build.json',
     decorators: { version: '2022-03' }, // stage-3 decorators
diff --git a/packages/react-native-sdk/src/preview-support.ts b/packages/react-native-sdk/src/preview-support.ts
new file mode 100644
index 00000000..a326e6a9
--- /dev/null
+++ b/packages/react-native-sdk/src/preview-support.ts
@@ -0,0 +1 @@
+export * from '@contentful/optimization-core/preview-support'
diff --git a/packages/react-native-sdk/src/preview/components/OverridesSection.tsx b/packages/react-native-sdk/src/preview/components/OverridesSection.tsx
index 65e1c353..93e0ef49 100644
--- a/packages/react-native-sdk/src/preview/components/OverridesSection.tsx
+++ b/packages/react-native-sdk/src/preview/components/OverridesSection.tsx
@@ -87,6 +87,7 @@ export function OverridesSection({
                 onPress: () => {
                   handleResetAudience(override.audienceId)
                 },
+                testID: `reset-audience-${override.audienceId}`,
               }}
             />
           ))}
@@ -108,6 +109,7 @@ export function OverridesSection({
                 onPress: () => {
                   handleResetOptimization(override.experienceId)
                 },
+                testID: `reset-variant-${override.experienceId}`,
               }}
             />
           ))}
diff --git a/packages/react-native-sdk/src/preview/components/PreviewPanel.tsx b/packages/react-native-sdk/src/preview/components/PreviewPanel.tsx
index 84dc45a3..ef98d536 100644
--- a/packages/react-native-sdk/src/preview/components/PreviewPanel.tsx
+++ b/packages/react-native-sdk/src/preview/components/PreviewPanel.tsx
@@ -243,6 +243,7 @@ export function PreviewPanel({
           variant="destructive"
           onPress={handleResetSdk}
           style={styles.resetButton}
+          testID="reset-all-overrides"
         />
       </View>
     </SafeAreaView>
diff --git a/packages/react-native-sdk/src/preview/components/PreviewPanelOverlay.tsx b/packages/react-native-sdk/src/preview/components/PreviewPanelOverlay.tsx
index b7f7bdc9..c76f00ca 100644
--- a/packages/react-native-sdk/src/preview/components/PreviewPanelOverlay.tsx
+++ b/packages/react-native-sdk/src/preview/components/PreviewPanelOverlay.tsx
@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import React, { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import {
   Animated,
   Image,
@@ -10,7 +10,7 @@ import {
   View,
 } from 'react-native'
 import { SafeAreaView } from 'react-native-safe-area-context'
-import { useLiveUpdates } from '../../context/LiveUpdatesContext'
+import { LiveUpdatesProvider, useLiveUpdates } from '../../context/LiveUpdatesContext'
 import fabIcon from '../assets/fab-icon.png'
 import fabRipple from '../assets/fab-ripple.png'
 import { PreviewOverrideProvider } from '../context/PreviewOverrideContext'
@@ -24,6 +24,16 @@ const DRAG_DISMISS_DISTANCE = 300
 const ANIMATION_DURATION_MS = 200
 const DRAG_HANDLE_HEIGHT = 4
 
+// Ensure an ambient LiveUpdatesProvider exists so panel visibility can flip
+// OptimizedEntry into live-update mode even when the overlay is used outside
+// OptimizationRoot. If a provider is already present (e.g. via OptimizationRoot)
+// pass through so its globalLiveUpdates setting isn't shadowed.
+function WithLiveUpdatesProvider({ children }: { children: ReactNode }): React.JSX.Element {
+  const existing = useLiveUpdates()
+  if (existing) return <>{children}</>
+  return <LiveUpdatesProvider>{children}</LiveUpdatesProvider>
+}
+
 /**
  * Renders app content with a floating action button that opens the `PreviewPanel`
  * in a bottom-sheet modal. Wraps children in a `PreviewOverrideProvider` to
@@ -41,7 +51,15 @@ const DRAG_HANDLE_HEIGHT = 4
  *
  * @public
  */
-export function PreviewPanelOverlay({
+export function PreviewPanelOverlay(props: PreviewPanelOverlayProps): React.JSX.Element {
+  return (
+    <WithLiveUpdatesProvider>
+      <PreviewPanelOverlayInner {...props} />
+    </WithLiveUpdatesProvider>
+  )
+}
+
+function PreviewPanelOverlayInner({
   children,
   fabPosition,
   ...previewPanelProps
@@ -136,6 +154,7 @@ export function PreviewPanelOverlay({
             android_ripple={null}
             onPress={handleOpen}
             style={() => styles.fabButton}
+            testID="preview-panel-fab"
           >
             {({ pressed }: { pressed: boolean }) => (
               <>
@@ -165,6 +184,7 @@ export function PreviewPanelOverlay({
                     handleClose(false)
                   }}
                   style={styles.closeButton}
+                  testID="preview-panel-close"
                 >
                   <Text style={styles.closeButtonText}>×</Text>
                 </Pressable>
diff --git a/packages/react-native-sdk/src/preview/components/VariantSelector.tsx b/packages/react-native-sdk/src/preview/components/VariantSelector.tsx
index adf0f822..85e57da5 100644
--- a/packages/react-native-sdk/src/preview/components/VariantSelector.tsx
+++ b/packages/react-native-sdk/src/preview/components/VariantSelector.tsx
@@ -9,6 +9,7 @@ type StyleArray = Array<StyleProp<ViewStyle>>
 
 interface VariantButtonProps {
   variant: VariantDistribution
+  experienceId: string
   isSelected: boolean
   isQualified: boolean
   isExperiment: boolean
@@ -45,6 +46,7 @@ function RadioButton({ isSelected }: { isSelected: boolean }): React.JSX.Element
 /** Single variant card within the selector */
 function VariantButton({
   variant,
+  experienceId,
   isSelected,
   isQualified,
   isExperiment,
@@ -62,6 +64,7 @@ function VariantButton({
       accessibilityRole="radio"
       accessibilityState={{ checked: isSelected }}
       accessibilityLabel={`${variantLabel}${percentageLabel ? `, ${percentageLabel}` : ''}`}
+      testID={`variant-picker-${experienceId}-${variant.index}`}
     >
       <View style={styles.variantContent}>
         <View style={styles.labelContainer}>
@@ -112,6 +115,7 @@ export function VariantSelector({
         <VariantButton
           key={variant.index}
           variant={variant}
+          experienceId={experience.id}
           isSelected={selectedIndex === variant.index}
           isQualified={qualifiedIndex === variant.index}
           isExperiment={isExperiment}
diff --git a/packages/react-native-sdk/src/preview/components/shared/ActionButton.tsx b/packages/react-native-sdk/src/preview/components/shared/ActionButton.tsx
index 9defa993..466dbfc6 100644
--- a/packages/react-native-sdk/src/preview/components/shared/ActionButton.tsx
+++ b/packages/react-native-sdk/src/preview/components/shared/ActionButton.tsx
@@ -49,6 +49,7 @@ export function ActionButton({
   onPress,
   disabled = false,
   style,
+  testID,
 }: ActionButtonProps): React.JSX.Element {
   const { [variant]: variantStyle } = variantStyles
   const isSecondary = variant === 'secondary'
@@ -65,6 +66,7 @@ export function ActionButton({
       onPress={onPress}
       disabled={disabled}
       activeOpacity={0.7}
+      testID={testID}
     >
       <Text style={[styles.buttonText, { color: variantStyle.textColor }]}>{label}</Text>
     </TouchableOpacity>
diff --git a/packages/react-native-sdk/src/preview/components/shared/AudienceToggle.tsx b/packages/react-native-sdk/src/preview/components/shared/AudienceToggle.tsx
index a6048441..a925778b 100644
--- a/packages/react-native-sdk/src/preview/components/shared/AudienceToggle.tsx
+++ b/packages/react-native-sdk/src/preview/components/shared/AudienceToggle.tsx
@@ -28,6 +28,7 @@ export function AudienceToggle({
       style={[styles.container, disabled && styles.disabled]}
       accessibilityRole="radiogroup"
       accessibilityLabel={`Audience toggle for ${audienceId}`}
+      testID={`audience-toggle-${audienceId}`}
     >
       {toggleStates.map((state) => {
         const isSelected = value === state.value
@@ -47,6 +48,7 @@ export function AudienceToggle({
             accessibilityRole="radio"
             accessibilityState={{ checked: isSelected, disabled }}
             accessibilityLabel={`Set audience to ${state.label}`}
+            testID={`audience-toggle-${audienceId}-${state.value}`}
             activeOpacity={0.7}
           >
             <Text style={[styles.buttonText, isSelected && styles.buttonTextSelected]}>
diff --git a/packages/react-native-sdk/src/preview/components/shared/ListItem.tsx b/packages/react-native-sdk/src/preview/components/shared/ListItem.tsx
index e3105ab4..496b9fba 100644
--- a/packages/react-native-sdk/src/preview/components/shared/ListItem.tsx
+++ b/packages/react-native-sdk/src/preview/components/shared/ListItem.tsx
@@ -45,7 +45,12 @@ export function ListItem({
 
       {action && (
         <View style={styles.actionContainer}>
-          <ActionButton label={action.label} variant={action.variant} onPress={action.onPress} />
+          <ActionButton
+            label={action.label}
+            variant={action.variant}
+            onPress={action.onPress}
+            testID={action.testID}
+          />
         </View>
       )}
     </View>
diff --git a/packages/react-native-sdk/src/preview/constants.ts b/packages/react-native-sdk/src/preview/constants.ts
index 4e502a58..9833184a 100644
--- a/packages/react-native-sdk/src/preview/constants.ts
+++ b/packages/react-native-sdk/src/preview/constants.ts
@@ -1,21 +1,5 @@
-/**
- * Fallback audience ID for experiences that don't target a specific audience.
- *
- * @public
- */
-export const ALL_VISITORS_AUDIENCE_ID = 'ALL_VISITORS'
-
-/**
- * Human-readable name for the fallback "All Visitors" audience.
- *
- * @public
- */
-export const ALL_VISITORS_AUDIENCE_NAME = 'All Visitors'
-
-/**
- * Description for the fallback "All Visitors" audience.
- *
- * @public
- */
-export const ALL_VISITORS_AUDIENCE_DESCRIPTION =
-  'Experiences that apply to all visitors regardless of audience membership'
+export {
+  ALL_VISITORS_AUDIENCE_DESCRIPTION,
+  ALL_VISITORS_AUDIENCE_ID,
+  ALL_VISITORS_AUDIENCE_NAME,
+} from '@contentful/optimization-core/preview-support'
diff --git a/packages/react-native-sdk/src/preview/hooks/usePreviewData.ts b/packages/react-native-sdk/src/preview/hooks/usePreviewData.ts
index 55dcc1bb..1d7d66cf 100644
--- a/packages/react-native-sdk/src/preview/hooks/usePreviewData.ts
+++ b/packages/react-native-sdk/src/preview/hooks/usePreviewData.ts
@@ -1,13 +1,7 @@
+import { buildPreviewModel, type PreviewModel } from '@contentful/optimization-core/preview-support'
 import { useMemo } from 'react'
-import {
-  ALL_VISITORS_AUDIENCE_DESCRIPTION,
-  ALL_VISITORS_AUDIENCE_ID,
-  ALL_VISITORS_AUDIENCE_NAME,
-} from '../constants'
 import type {
   AudienceDefinition,
-  AudienceOverrideState,
-  AudienceWithExperiences,
   ExperienceDefinition,
   OverrideState,
   PreviewState,
@@ -24,27 +18,11 @@ interface UsePreviewDataParams {
   overrides: OverrideState
 }
 
-interface UsePreviewDataResult {
-  /** Audiences with their associated experiences and computed states */
-  audiencesWithExperiences: AudienceWithExperiences[]
-  /** Experiences that don't have an associated audience (global experiences) */
-  unassociatedExperiences: ExperienceDefinition[]
-  /** Whether any data is available */
-  hasData: boolean
-  /** Map of experienceId to variantIndex from SDK selected optimizations */
-  sdkVariantIndices: Record<string, number>
-}
-
 /**
  * Combines audience and experience definitions with SDK state to produce
  * a unified view of all optimization data, grouped by audience.
  *
- * @param params - Audience/experience definitions, preview state, and overrides
- * @returns Audiences with experiences, unassociated experiences, and SDK variant indices
- *
- * @remarks
- * Experiences without a specific audience are grouped under an
- * "All Visitors" fallback audience.
+ * Thin React wrapper around `buildPreviewModel` from `@contentful/optimization-core/preview-support`.
  *
  * @internal
  */
@@ -53,123 +31,17 @@ export function usePreviewData({
   experienceDefinitions,
   previewState,
   overrides,
-}: UsePreviewDataParams): UsePreviewDataResult {
-  const { profile, selectedOptimizations } = previewState
-
-  // Get the set of audience IDs that the user qualifies for from the API
-  const qualifiedAudienceIds = useMemo(
-    () => new Set(profile?.audiences ?? []),
-    [profile?.audiences],
+}: UsePreviewDataParams): PreviewModel {
+  return useMemo(
+    () =>
+      buildPreviewModel({
+        audienceDefinitions,
+        experienceDefinitions,
+        signals: previewState,
+        overrides,
+      }),
+    [audienceDefinitions, experienceDefinitions, previewState, overrides],
   )
-
-  // Create a lookup of experienceId -> variantIndex from SDK selected optimizations
-  const sdkVariantIndices = useMemo(() => {
-    if (!selectedOptimizations) return {}
-    return selectedOptimizations.reduce<Record<string, number>>((acc, p) => {
-      const { experienceId, variantIndex } = p
-      acc[experienceId] = variantIndex
-      return acc
-    }, {})
-  }, [selectedOptimizations])
-
-  // Find experiences without an associated audience (global experiences)
-  const unassociatedExperiences = useMemo(() => {
-    const audienceIds = new Set(audienceDefinitions.map((a) => a.id))
-    return experienceDefinitions.filter((exp) => {
-      // Include if no audience specified
-      if (!exp.audience?.id) return true
-      // Include if the audience doesn't exist in definitions
-      return !audienceIds.has(exp.audience.id)
-    })
-  }, [audienceDefinitions, experienceDefinitions])
-
-  // Compute audiences with their experiences
-  const audiencesWithExperiences = useMemo(() => {
-    const result: AudienceWithExperiences[] = []
-
-    // Process defined audiences
-    audienceDefinitions.forEach((audience) => {
-      // Find experiences targeting this audience
-      const experiences = experienceDefinitions.filter((exp) => exp.audience?.id === audience.id)
-
-      // Check if user naturally qualifies for this audience
-      const isQualified = qualifiedAudienceIds.has(audience.id)
-
-      // Determine override state
-      const {
-        audiences: { [audience.id]: audienceOverride },
-      } = overrides
-      let overrideState: AudienceOverrideState = 'default'
-      if (audienceOverride) {
-        overrideState = audienceOverride.isActive ? 'on' : 'off'
-      }
-
-      // Compute if audience is currently active (considering overrides)
-      let isActive = isQualified
-      if (overrideState === 'on') {
-        isActive = true
-      } else if (overrideState === 'off') {
-        isActive = false
-      }
-
-      result.push({
-        audience,
-        experiences,
-        isQualified,
-        isActive,
-        overrideState,
-      })
-    })
-
-    // Add "All Visitors" fallback audience if there are unassociated experiences
-    if (unassociatedExperiences.length > 0) {
-      const allVisitorsAudience: AudienceDefinition = {
-        id: ALL_VISITORS_AUDIENCE_ID,
-        name: ALL_VISITORS_AUDIENCE_NAME,
-        description: ALL_VISITORS_AUDIENCE_DESCRIPTION,
-      }
-
-      // Check for override on the fallback audience
-      const {
-        audiences: { [ALL_VISITORS_AUDIENCE_ID]: allVisitorsOverride },
-      } = overrides
-      let overrideState: AudienceOverrideState = 'default'
-      if (allVisitorsOverride) {
-        overrideState = allVisitorsOverride.isActive ? 'on' : 'off'
-      }
-
-      // All Visitors is always qualified and active by default
-      let isActive = true
-      if (overrideState === 'off') {
-        isActive = false
-      }
-
-      result.push({
-        audience: allVisitorsAudience,
-        experiences: unassociatedExperiences,
-        isQualified: true, // All users qualify for All Visitors
-        isActive,
-        overrideState,
-      })
-    }
-
-    return result
-  }, [
-    audienceDefinitions,
-    experienceDefinitions,
-    qualifiedAudienceIds,
-    overrides.audiences,
-    unassociatedExperiences,
-  ])
-
-  const hasData = audienceDefinitions.length > 0 || experienceDefinitions.length > 0
-
-  return {
-    audiencesWithExperiences,
-    unassociatedExperiences,
-    hasData,
-    sdkVariantIndices,
-  }
 }
 
 export default usePreviewData
diff --git a/packages/react-native-sdk/src/preview/hooks/useProfileOverrides.ts b/packages/react-native-sdk/src/preview/hooks/useProfileOverrides.ts
index 30866bed..8aea5015 100644
--- a/packages/react-native-sdk/src/preview/hooks/useProfileOverrides.ts
+++ b/packages/react-native-sdk/src/preview/hooks/useProfileOverrides.ts
@@ -1,19 +1,10 @@
-import type { PreviewPanelSignalObject, Signals } from '@contentful/optimization-core'
-import type {
-  OptimizationData,
-  SelectedOptimizationArray,
-} from '@contentful/optimization-core/api-schemas'
+import type { PreviewPanelSignalObject } from '@contentful/optimization-core'
 import { createScopedLogger } from '@contentful/optimization-core/logger'
+import { PreviewOverrideManager } from '@contentful/optimization-core/preview-support'
 import { PREVIEW_PANEL_SIGNALS_SYMBOL } from '@contentful/optimization-core/symbols'
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useOptimization } from '../../context/OptimizationContext'
-import type {
-  AudienceOverride,
-  ExperienceDefinition,
-  OptimizationOverride,
-  OverrideState,
-  PreviewActions,
-} from '../types'
+import type { ExperienceDefinition, OverrideState, PreviewActions } from '../types'
 
 const logger = createScopedLogger('RN:Preview')
 
@@ -22,45 +13,12 @@ const initialOverrideState: OverrideState = {
   selectedOptimizations: {},
 }
 
-/**
- * @internal
- */
-function applyOptimizationOverrides(
-  apiSelectedOptimizations: SelectedOptimizationArray,
-  overrides: Record<string, OptimizationOverride>,
-): SelectedOptimizationArray {
-  const overrideEntries = Object.values(overrides)
-  if (overrideEntries.length === 0) return apiSelectedOptimizations
-
-  const overridden = apiSelectedOptimizations.map((selectedOptimization) => {
-    const { [selectedOptimization.experienceId]: override } = overrides
-    if (override) {
-      return {
-        ...selectedOptimization,
-        variantIndex: override.variantIndex,
-      }
-    }
-    return selectedOptimization
-  })
-
-  for (const override of overrideEntries) {
-    if (!overridden.some((selected) => selected.experienceId === override.experienceId)) {
-      overridden.push({
-        experienceId: override.experienceId,
-        variantIndex: override.variantIndex,
-        variants: {},
-      })
-    }
-  }
-
-  return overridden
-}
-
 /**
  * Manages profile and optimization overrides in the preview panel.
  *
- * Registers with the SDK to get direct signal access and sets up a state
- * interceptor to preserve overrides when API responses arrive.
+ * Delegates to a shared {@link PreviewOverrideManager} that registers a state
+ * interceptor to preserve overrides when API responses arrive, and provides
+ * methods to activate/deactivate audiences and set variant overrides.
  *
  * @returns An object containing the current override state and available actions
  *
@@ -74,266 +32,93 @@ export function useProfileOverrides(): {
 } {
   const contentfulOptimization = useOptimization()
   const [overrides, setOverrides] = useState<OverrideState>(initialOverrideState)
+  const managerRef = useRef<PreviewOverrideManager | null>(null)
 
-  // Store signals reference obtained from SDK registration
-  const signalsRef = useRef<Signals | null | undefined>(null)
-
-  // Store interceptor ID for cleanup
-  const interceptorIdRef = useRef<number | null>(null)
-
-  // Store current overrides in a ref so the interceptor can access latest values
-  const overridesRef = useRef<OverrideState>(initialOverrideState)
-
-  // Store the last un-overridden data from the API
-  const lastActualDataRef = useRef<OptimizationData | null>(null)
-
-  // Keep overridesRef in sync with state
-  useEffect(() => {
-    overridesRef.current = overrides
-  }, [overrides])
-
-  // Register with SDK and set up interceptor on mount
   useEffect(() => {
     // Create a preview panel compatible object to receive signals
     const previewPanelObject: PreviewPanelSignalObject = {}
 
     // Register with the SDK to get signal access
     contentfulOptimization.registerPreviewPanel(previewPanelObject)
-    const registeredSignals = Reflect.get(previewPanelObject, PREVIEW_PANEL_SIGNALS_SYMBOL)
-    signalsRef.current = registeredSignals
+    const signals = Reflect.get(previewPanelObject, PREVIEW_PANEL_SIGNALS_SYMBOL)
 
-    logger.info('Registered with SDK, signals access obtained')
-
-    // Capture current signal state as the initial "actual" data
-    // This ensures we have data to restore to even if no API calls happen after mounting
-    if (signalsRef.current && !lastActualDataRef.current) {
-      const { current } = signalsRef
-      const {
-        selectedOptimizations: { value: selectedOptimizations },
-        profile: { value: profile },
-        changes: { value: changes },
-      } = current
-      if (selectedOptimizations && profile && changes) {
-        const actualData: OptimizationData = {
-          selectedOptimizations,
-          profile,
-          changes,
-        }
-        lastActualDataRef.current = actualData
-        logger.debug('Captured initial signal state as actual data')
-      }
+    if (!signals) {
+      logger.warn('Failed to obtain signals from SDK registration')
+      return
     }
 
-    // Register state interceptor to preserve overrides when API responses arrive
-    interceptorIdRef.current = contentfulOptimization.interceptors.state.add(
-      (data: OptimizationData): OptimizationData => {
-        // Cache the un-overridden data
-        lastActualDataRef.current = data
-
-        const { current: currentOverrides } = overridesRef
-
-        // If no optimization overrides, pass through unchanged
-        if (Object.keys(currentOverrides.selectedOptimizations).length === 0) {
-          return data
-        }
-
-        logger.debug('Intercepting state update to preserve overrides')
+    logger.info('Registered with SDK, signals access obtained')
 
-        // Merge API response with our overrides
-        return {
-          ...data,
-          selectedOptimizations: applyOptimizationOverrides(
-            data.selectedOptimizations,
-            currentOverrides.selectedOptimizations,
-          ),
-        }
+    const manager = new PreviewOverrideManager({
+      selectedOptimizations: signals.selectedOptimizations,
+      profile: signals.profile,
+      stateInterceptors: contentfulOptimization.interceptors.state,
+      onOverridesChanged: (state) => {
+        setOverrides({ ...state })
       },
-    )
+    })
+    managerRef.current = manager
 
-    logger.info('State interceptor registered')
-
-    // Cleanup on unmount
     return () => {
-      if (interceptorIdRef.current !== null) {
-        contentfulOptimization.interceptors.state.remove(interceptorIdRef.current)
-        logger.info('State interceptor removed')
-      }
-      signalsRef.current = null
+      manager.destroy()
+      managerRef.current = null
     }
   }, [contentfulOptimization])
 
-  // Helper to recompute the signal from the clean API baseline + current overrides.
-  // Mirrors the web preview's `syncOverrides` pattern: always derive from the
-  // un-overridden API state rather than layering onto the (possibly stale) signal.
-  const syncOverridesToSignal = useCallback(
-    (currentOverrides: Record<string, OptimizationOverride>) => {
-      const { current: signals } = signalsRef
-      if (!signals) return
-
-      signals.selectedOptimizations.value = applyOptimizationOverrides(
-        lastActualDataRef.current?.selectedOptimizations ?? [],
-        currentOverrides,
-      )
-      logger.debug('Synced overrides to signal')
-    },
-    [],
-  )
-
-  const setAudienceOverride = useCallback(
-    (
-      audienceId: string,
-      isActive: boolean,
-      variantIndex: number,
-      experiences: ExperienceDefinition[],
-    ) => {
-      logger.info('Setting audience override:', { audienceId, isActive })
-
-      const experienceIds = experiences.map((exp) => exp.id)
-
-      setOverrides((prev) => {
-        const newSelectedOptimizations = { ...prev.selectedOptimizations }
-        experiences.forEach((exp) => {
-          newSelectedOptimizations[exp.id] = { experienceId: exp.id, variantIndex }
-        })
-
-        if (experiences.length > 0) {
-          syncOverridesToSignal(newSelectedOptimizations)
-        }
-
-        return {
-          ...prev,
-          audiences: {
-            ...prev.audiences,
-            [audienceId]: { audienceId, isActive, source: 'manual', experienceIds },
-          },
-          selectedOptimizations: newSelectedOptimizations,
-        }
-      })
-    },
-    [syncOverridesToSignal],
-  )
-
   const activateAudience = useCallback(
     (audienceId: string, experiences: ExperienceDefinition[]) => {
-      setAudienceOverride(audienceId, true, 1, experiences)
+      managerRef.current?.activateAudience(
+        audienceId,
+        experiences.map((exp) => exp.id),
+      )
     },
-    [setAudienceOverride],
+    [],
   )
 
   const deactivateAudience = useCallback(
     (audienceId: string, experiences: ExperienceDefinition[]) => {
-      setAudienceOverride(audienceId, false, 0, experiences)
-    },
-    [setAudienceOverride],
-  )
-
-  const resetAudienceOverride = useCallback(
-    (audienceId: string) => {
-      logger.info('Resetting audience override:', audienceId)
-
-      setOverrides((prev) => {
-        // Get the stored experience IDs from the audience override
-        const storedExperienceIds = prev.audiences[audienceId]?.experienceIds ?? []
-        const experienceIdSet = new Set(storedExperienceIds)
-
-        const newSelectedOptimizations = Object.fromEntries(
-          Object.entries(prev.selectedOptimizations).filter(([key]) => !experienceIdSet.has(key)),
-        ) as Record<string, OptimizationOverride>
-
-        if (storedExperienceIds.length > 0) {
-          syncOverridesToSignal(newSelectedOptimizations)
-        }
-
-        return {
-          ...prev,
-          audiences: Object.fromEntries(
-            Object.entries(prev.audiences).filter(([key]) => key !== audienceId),
-          ) as Record<string, AudienceOverride>,
-          selectedOptimizations: newSelectedOptimizations,
-        }
-      })
-    },
-    [syncOverridesToSignal],
-  )
-
-  const setVariantOverride = useCallback(
-    (experienceId: string, variantIndex: number) => {
-      logger.info('Setting variant override:', {
-        experienceId,
-        variantIndex,
-      })
-
-      setOverrides((prev) => {
-        const newOverride: OptimizationOverride = {
-          experienceId,
-          variantIndex,
-        }
-        const newSelectedOptimizations = {
-          ...prev.selectedOptimizations,
-          [experienceId]: newOverride,
-        }
-
-        // Update signals directly for immediate feedback
-        syncOverridesToSignal(newSelectedOptimizations)
-
-        return {
-          ...prev,
-          selectedOptimizations: newSelectedOptimizations,
-        }
-      })
+      managerRef.current?.deactivateAudience(
+        audienceId,
+        experiences.map((exp) => exp.id),
+      )
     },
-    [syncOverridesToSignal],
+    [],
   )
 
-  const resetOptimizationOverride = useCallback(
-    (experienceId: string) => {
-      logger.info('Resetting optimization override:', experienceId)
-
-      setOverrides((prev) => {
-        const newSelectedOptimizations = Object.fromEntries(
-          Object.entries(prev.selectedOptimizations).filter(([key]) => key !== experienceId),
-        ) as Record<string, OptimizationOverride>
+  const resetAudienceOverride = useCallback((audienceId: string) => {
+    managerRef.current?.resetAudienceOverride(audienceId)
+  }, [])
 
-        // Update signals directly for immediate feedback
-        syncOverridesToSignal(newSelectedOptimizations)
+  const setVariantOverride = useCallback((experienceId: string, variantIndex: number) => {
+    managerRef.current?.setVariantOverride(experienceId, variantIndex)
+  }, [])
 
-        return {
-          ...prev,
-          selectedOptimizations: newSelectedOptimizations,
-        }
-      })
-    },
-    [syncOverridesToSignal],
-  )
+  const resetOptimizationOverride = useCallback((experienceId: string) => {
+    managerRef.current?.resetOptimizationOverride(experienceId)
+  }, [])
 
   const resetSdkState = useCallback(() => {
-    logger.info('Resetting SDK state to actual')
-    // Instead of completely clearing the SDK state with contentfulOptimization.reset(),
-    // we just clear our overrides and restore the last known actual state from the API.
-    setOverrides(initialOverrideState)
-
-    // Restore signals to actual data if we have it
-    if (lastActualDataRef.current && signalsRef.current) {
-      const {
-        current: { selectedOptimizations, profile, changes },
-      } = lastActualDataRef
-      const { current: signals } = signalsRef
-
-      signals.selectedOptimizations.value = selectedOptimizations
-      signals.profile.value = profile
-      signals.changes.value = changes
-      logger.debug('Restored signals to actual data')
-    }
+    managerRef.current?.resetAll()
   }, [])
 
-  const actions: PreviewActions = {
-    activateAudience,
-    deactivateAudience,
-    resetAudienceOverride,
-    setVariantOverride,
-    resetOptimizationOverride,
-    resetSdkState,
-  }
+  const actions: PreviewActions = useMemo(
+    () => ({
+      activateAudience,
+      deactivateAudience,
+      resetAudienceOverride,
+      setVariantOverride,
+      resetOptimizationOverride,
+      resetSdkState,
+    }),
+    [
+      activateAudience,
+      deactivateAudience,
+      resetAudienceOverride,
+      setVariantOverride,
+      resetOptimizationOverride,
+      resetSdkState,
+    ],
+  )
 
   return {
     overrides,
diff --git a/packages/react-native-sdk/src/preview/types.ts b/packages/react-native-sdk/src/preview/types.ts
index f1eda4c4..9cea60c3 100644
--- a/packages/react-native-sdk/src/preview/types.ts
+++ b/packages/react-native-sdk/src/preview/types.ts
@@ -1,202 +1,40 @@
 import type { Profile, SelectedOptimization } from '@contentful/optimization-core/api-schemas'
+import type {
+  AudienceOverrideState,
+  AudienceWithExperiences,
+  ContentfulClient,
+  ExperienceDefinition,
+  OptimizationOverride,
+  OverrideState,
+  PreviewSdkSignals,
+} from '@contentful/optimization-core/preview-support'
 import type { StyleProp, ViewStyle } from 'react-native'
 
 // ============================================================================
-// Audience & Experience Definitions
+// Re-exports from core
 // ============================================================================
 
-/**
- * Audience definition from the optimization platform.
- *
- * @internal
- */
-export interface AudienceDefinition {
-  /** Unique audience identifier */
-  id: string
-  /** Human-readable audience name */
-  name: string
-  /** Optional description of audience targeting criteria */
-  description?: string
-}
-
-/**
- * Variant distribution configuration for an experience.
- *
- * @internal
- */
-export interface VariantDistribution {
-  /** Variant index (0 = baseline) */
-  index: number
-  /** Reference to the variant content */
-  variantRef: string
-  /** Optional traffic percentage (0-100) */
-  percentage?: number
-  /** Optional human-readable name from Contentful entry */
-  name?: string
-}
-
-// ============================================================================
-// Contentful Entry Types (for enrichment)
-// ============================================================================
-
-/**
- * Simplified Contentful entry structure for mapping entries to preview panel definitions.
- *
- * @internal
- */
-export interface ContentfulEntry {
-  sys: {
-    id: string
-    contentType?: {
-      sys: {
-        id: string
-      }
-    }
-  }
-  fields: Record<string, unknown>
-}
-
-/**
- * Entry collection response from the Contentful client, including pagination metadata.
- *
- * @internal
- */
-export interface ContentfulEntryCollection {
-  items: ContentfulEntry[]
-  total: number
-  skip: number
-  limit: number
-}
-
-/**
- * Minimal Contentful client interface required by the preview panel.
- *
- * @public
- */
-export interface ContentfulClient {
-  getEntries: (query: {
-    content_type: string
-    include?: number
-    skip?: number
-    limit?: number
-  }) => Promise<ContentfulEntryCollection>
-}
-
-/**
- * Experience definition representing a personalization or experiment configuration.
- *
- * @internal
- */
-export interface ExperienceDefinition {
-  /** Unique experience identifier */
-  id: string
-  /** Human-readable experience name */
-  name: string
-  /** Type of experience */
-  type: 'nt_personalization' | 'nt_experiment'
-  /** Variant distribution configuration */
-  distribution: VariantDistribution[]
-  /** Associated audience (if audience-targeted) */
-  audience?: { id: string }
-}
-
-/**
- * Three-state override value for audiences: `'on'` forces active, `'off'` forces
- * inactive, `'default'` defers to the SDK evaluation.
- *
- * @internal
- */
-export type AudienceOverrideState = 'on' | 'off' | 'default'
-
-/**
- * Combined audience data with associated experiences, used for audience-grouped display.
- *
- * @internal
- */
-export interface AudienceWithExperiences {
-  /** Audience definition */
-  audience: AudienceDefinition
-  /** Experiences targeting this audience */
-  experiences: ExperienceDefinition[]
-  /** Whether user naturally qualifies for this audience (from API) */
-  isQualified: boolean
-  /** Whether audience is currently active (considering overrides) */
-  isActive: boolean
-  /** Current override state */
-  overrideState: AudienceOverrideState
-}
-
-/**
- * Preview data containing all audience and experience definitions.
- *
- * @internal
- */
-export interface PreviewData {
-  /** All available audience definitions */
-  audienceDefinitions: AudienceDefinition[]
-  /** All available experience definitions */
-  experienceDefinitions: ExperienceDefinition[]
-}
-
-// ============================================================================
-// Override State Types
-// ============================================================================
-
-/**
- * Tracks a manual audience activation or deactivation override.
- *
- * @internal
- */
-export interface AudienceOverride {
-  /** Audience ID being overridden */
-  audienceId: string
-  /** Whether the audience is activated (true) or deactivated (false) */
-  isActive: boolean
-  /** Source of the override - 'manual' for user-initiated */
-  source: 'manual'
-  /** Experience IDs that were set with this audience override */
-  experienceIds: string[]
-}
-
-/**
- * Tracks a manual variant selection override.
- *
- * @internal
- */
-export interface OptimizationOverride {
-  /** Experience ID being overridden */
-  experienceId: string
-  /** The variant index to force (0 = baseline) */
-  variantIndex: number
-}
-
-/**
- * Combined override state managed by the preview panel.
- *
- * @internal
- */
-export interface OverrideState {
-  /** Map of audience ID to override */
-  audiences: Record<string, AudienceOverride>
-  /** Map of experience ID to override */
-  selectedOptimizations: Record<string, OptimizationOverride>
-}
+export type {
+  AudienceDefinition,
+  AudienceOverride,
+  AudienceOverrideState,
+  AudienceWithExperiences,
+  ContentfulClient,
+  ContentfulEntry,
+  ContentfulEntryCollection,
+  ExperienceDefinition,
+  OptimizationOverride,
+  OverrideState,
+  PreviewData,
+  VariantDistribution,
+} from '@contentful/optimization-core/preview-support'
 
 /**
  * Preview state derived from SDK signals.
  *
  * @internal
  */
-export interface PreviewState {
-  /** Current profile from SDK */
-  profile: Profile | undefined
-  /** Current selected optimizations from SDK */
-  selectedOptimizations: SelectedOptimization[] | undefined
-  /** Current consent state */
-  consent: boolean | undefined
-  /** Whether SDK data is loading */
-  isLoading: boolean
-}
+export type PreviewState = PreviewSdkSignals
 
 /**
  * Actions available in the preview panel for overriding audiences and optimizations.
@@ -285,6 +123,7 @@ export interface ListItemProps {
     label: string
     variant: 'activate' | 'deactivate' | 'reset'
     onPress: () => void
+    testID?: string
   }
   /** Badge to display */
   badge?: {
@@ -311,6 +150,8 @@ export interface ActionButtonProps {
   disabled?: boolean
   /** Custom style */
   style?: StyleProp<ViewStyle>
+  /** Test ID for automated UI testing */
+  testID?: string
 }
 
 /**
diff --git a/packages/react-native-sdk/src/preview/utils/contentfulUtils.ts b/packages/react-native-sdk/src/preview/utils/contentfulUtils.ts
index f69ad6ed..e9421af3 100644
--- a/packages/react-native-sdk/src/preview/utils/contentfulUtils.ts
+++ b/packages/react-native-sdk/src/preview/utils/contentfulUtils.ts
@@ -1,76 +1,4 @@
-import { createScopedLogger } from '@contentful/optimization-core/logger'
-import type { ContentfulClient, ContentfulEntry } from '../types'
-
-const logger = createScopedLogger('RN:Preview')
-const BATCH_SIZE = 100
-
-/**
- * Fetches all entries of a specific content type from Contentful,
- * handling pagination automatically by batching requests.
- *
- * @param client - The Contentful client instance
- * @param contentType - The content type ID to fetch (e.g., `'nt_audience'`, `'nt_experience'`)
- * @param include - Depth of linked entries to resolve
- * @returns Promise resolving to an array of all entries
- *
- * @defaultValue `10`
- *
- * @public
- */
-export async function fetchAllEntriesByContentType(
-  client: ContentfulClient,
-  contentType: string,
-  include = 10,
-): Promise<ContentfulEntry[]> {
-  const allEntries: ContentfulEntry[] = []
-  let skip = 0
-  let total = 0
-
-  do {
-    const response = await client.getEntries({
-      content_type: contentType,
-      include,
-      skip,
-      limit: BATCH_SIZE,
-    })
-
-    const { items, total: responseTotal } = response
-    allEntries.push(...items)
-    total = responseTotal
-    skip += BATCH_SIZE
-
-    logger.debug(`Fetched ${contentType} batch`, {
-      fetched: response.items.length,
-      accumulated: allEntries.length,
-      total,
-    })
-  } while (allEntries.length < total)
-
-  return allEntries
-}
-
-/**
- * Fetches all audience and experience entries from Contentful in parallel.
- *
- * @param client - The Contentful client instance
- * @returns Promise resolving to an object containing audience and experience entries
- *
- * @public
- */
-export async function fetchAudienceAndExperienceEntries(
-  client: ContentfulClient,
-): Promise<{ audiences: ContentfulEntry[]; experiences: ContentfulEntry[] }> {
-  logger.debug('Fetching audience and experience entries...')
-
-  const [audiences, experiences] = await Promise.all([
-    fetchAllEntriesByContentType(client, 'nt_audience'),
-    fetchAllEntriesByContentType(client, 'nt_experience'),
-  ])
-
-  logger.debug('All entries fetched successfully', {
-    audienceCount: audiences.length,
-    experienceCount: experiences.length,
-  })
-
-  return { audiences, experiences }
-}
+export {
+  fetchAllEntriesByContentType,
+  fetchAudienceAndExperienceEntries,
+} from '@contentful/optimization-core/preview-support'
diff --git a/packages/react-native-sdk/src/preview/utils/entryMappers.ts b/packages/react-native-sdk/src/preview/utils/entryMappers.ts
index bc910bec..0dd2a7aa 100644
--- a/packages/react-native-sdk/src/preview/utils/entryMappers.ts
+++ b/packages/react-native-sdk/src/preview/utils/entryMappers.ts
@@ -1,203 +1,5 @@
-import type {
-  AudienceDefinition,
-  ContentfulEntry,
-  ExperienceDefinition,
-  VariantDistribution,
-} from '../types'
-
-/** @internal */
-interface AudienceEntryFields {
-  nt_audience_id?: string
-  nt_name?: string
-  nt_description?: string
-}
-
-/** @internal */
-interface ExperienceEntryFields {
-  nt_experience_id?: string
-  nt_name?: string
-  nt_type?: 'nt_personalization' | 'nt_experiment'
-  nt_config?: {
-    distribution?: number[]
-    components?: Array<{
-      baseline?: { id: string }
-      variants?: Array<{ id: string; hidden?: boolean }>
-    }>
-  } | null
-  nt_audience?: { sys: { id: string } } | null
-  nt_variants?: Array<{ sys: { id: string } }>
-}
-
-/** @internal */
-interface OptimizationEntryFields {
-  nt_personalization_id?: string
-  nt_experience_id?: string
-  nt_name?: string
-}
-
-/** @internal */
-interface VariantEntryFields {
-  internalTitle?: string
-  title?: string
-  name?: string
-}
-
-/** @internal */
-function hasAudienceFields(fields: unknown): fields is AudienceEntryFields {
-  return typeof fields === 'object' && fields !== null
-}
-
-/** @internal */
-function hasExperienceFields(fields: unknown): fields is ExperienceEntryFields {
-  return typeof fields === 'object' && fields !== null
-}
-
-/** @internal */
-function hasVariantFields(fields: unknown): fields is VariantEntryFields {
-  return typeof fields === 'object' && fields !== null
-}
-
-/** @internal */
-function hasOptimizationFields(fields: unknown): fields is OptimizationEntryFields {
-  return typeof fields === 'object' && fields !== null
-}
-
-/** @internal */
-function getVariantName(entry: ContentfulEntry): string | undefined {
-  const fields: unknown = entry.fields
-  if (hasVariantFields(fields)) {
-    return fields.internalTitle ?? fields.title ?? fields.name
-  }
-  return undefined
-}
-
-/** @internal */
-function getVariantRefForIndex(
-  index: number,
-  config: NonNullable<ExperienceEntryFields['nt_config']>,
-): string {
-  const firstComponent = config.components?.[0]
-  if (index === 0) {
-    return firstComponent?.baseline?.id ?? ''
-  }
-  return firstComponent?.variants?.[index - 1]?.id ?? ''
-}
-
-/** @internal */
-function buildVariantEntryMap(experienceEntries: ContentfulEntry[]): Map<string, ContentfulEntry> {
-  const variantMap = new Map<string, ContentfulEntry>()
-
-  experienceEntries.forEach((entry) => {
-    const entryWithIncludes = entry as ContentfulEntry & {
-      includes?: { Entry?: ContentfulEntry[] }
-    }
-    const includedEntries = entryWithIncludes.includes?.Entry ?? []
-
-    includedEntries.forEach((includedEntry) => {
-      variantMap.set(includedEntry.sys.id, includedEntry)
-    })
-  })
-
-  return variantMap
-}
-
-/**
- * Creates {@link AudienceDefinition} instances from Contentful `nt_audience` entries.
- *
- * @param entries - Contentful entries of type `nt_audience`
- * @returns Array of audience definitions
- *
- * @public
- */
-export function createAudienceDefinitions(entries: ContentfulEntry[]): AudienceDefinition[] {
-  return entries.map((entry) => {
-    const fields: unknown = entry.fields
-    if (hasAudienceFields(fields)) {
-      return {
-        id: fields.nt_audience_id ?? entry.sys.id,
-        name: fields.nt_name ?? fields.nt_audience_id ?? entry.sys.id,
-        description: fields.nt_description,
-      }
-    }
-    return {
-      id: entry.sys.id,
-      name: entry.sys.id,
-    }
-  })
-}
-
-/**
- * Creates {@link ExperienceDefinition} instances from Contentful `nt_experience` entries,
- * including variant distribution with names extracted from linked entries.
- *
- * @param entries - Contentful entries of type `nt_experience`
- * @returns Array of experience definitions with full variant information
- *
- * @public
- */
-export function createExperienceDefinitions(entries: ContentfulEntry[]): ExperienceDefinition[] {
-  const variantEntryMap = buildVariantEntryMap(entries)
-
-  return entries.map((entry) => {
-    const fields: unknown = entry.fields
-    if (!hasExperienceFields(fields)) {
-      return {
-        id: entry.sys.id,
-        name: entry.sys.id,
-        type: 'nt_personalization' as const,
-        distribution: [],
-      }
-    }
-
-    const { nt_config: config } = fields
-    const distribution: VariantDistribution[] = []
-
-    if (config?.distribution) {
-      config.distribution.forEach((percentage, index) => {
-        const variantRef = getVariantRefForIndex(index, config)
-        const variantEntry = variantEntryMap.get(variantRef)
-
-        distribution.push({
-          index,
-          variantRef,
-          percentage: Math.round(percentage * 100),
-          name: variantEntry ? getVariantName(variantEntry) : undefined,
-        })
-      })
-    }
-
-    return {
-      id: fields.nt_experience_id ?? entry.sys.id,
-      name: fields.nt_name ?? entry.sys.id,
-      type: fields.nt_type ?? 'nt_personalization',
-      distribution,
-      audience: fields.nt_audience ? { id: fields.nt_audience.sys.id } : undefined,
-    }
-  })
-}
-
-/**
- * Creates a lookup map of experience IDs to their human-readable names.
- *
- * @param entries - Contentful entries of type `nt_experience`
- * @returns Record mapping experience IDs to display names
- *
- * @public
- */
-export function createExperienceNameMap(entries: ContentfulEntry[]): Record<string, string> {
-  const nameMap: Record<string, string> = {}
-
-  entries.forEach((entry) => {
-    const fields: unknown = entry.fields
-    if (hasOptimizationFields(fields)) {
-      const id = fields.nt_personalization_id ?? fields.nt_experience_id ?? entry.sys.id
-
-      const { nt_name: name } = fields
-      if (name) {
-        nameMap[id] = name
-      }
-    }
-  })
-
-  return nameMap
-}
+export {
+  createAudienceDefinitions,
+  createExperienceDefinitions,
+  createExperienceNameMap,
+} from '@contentful/optimization-core/preview-support'
diff --git a/packages/universal/core-sdk/AGENTS.md b/packages/universal/core-sdk/AGENTS.md
index 2a00cd55..b1bc7d25 100644
--- a/packages/universal/core-sdk/AGENTS.md
+++ b/packages/universal/core-sdk/AGENTS.md
@@ -5,17 +5,28 @@ Read the repository root `AGENTS.md` first.
 ## Scope
 
 This package owns platform-agnostic optimization business logic and the shared stateful and
-stateless core used by all platform SDKs.
+stateless core used by all platform SDKs. It also owns the cross-platform preview-panel support
+toolkit (override management, preview-model building, Contentful entry mapping) that powers the
+preview panels shipped with the platform SDKs.
 
 ## Key Paths
 
-- `src/`
+- `src/` — root entry: stateless/stateful core, signals, events, queues, interceptors, resolvers
+- `src/preview-support/` — preview-panel toolkit (`PreviewOverrideManager`, `buildPreviewModel`,
+  Contentful entry mappers, fetch helpers); exposed via the dedicated `./preview-support` entry
+  point
 - `README.md`
 
 ## Local Rules
 
 - Prefer shared behavior fixes here when the problem affects more than one platform SDK.
 - Do not introduce platform-specific browser, Node, or React Native assumptions here.
+- Contentful content-model knowledge (`nt_audience`, `nt_experience`, `nt_config`, …) lives only
+  under `src/preview-support/`. Keep the rest of core platform-agnostic and free of Contentful
+  schema knowledge.
+- The `./preview-support` entry is consumed by the React Native SDK (re-exported as its own
+  `./preview-support` entry) and the iOS JSC bridge. Re-validate those when changing public behavior
+  under `src/preview-support/`.
 - Changes in this package often cascade to Node, Web, and React Native SDKs. Validate accordingly.
 - Update README and TSDoc when public behavior changes.
 
diff --git a/packages/universal/core-sdk/README.md b/packages/universal/core-sdk/README.md
index e38e4d23..a5542616 100644
--- a/packages/universal/core-sdk/README.md
+++ b/packages/universal/core-sdk/README.md
@@ -54,10 +54,10 @@ other SDKs descend from the Core SDK.
   - [`reset`](#reset)
   - [`flush`](#flush)
   - [`destroy`](#destroy)
-  - [`registerPreviewPanel` (preview tooling only)](#registerpreviewpanel-preview-tooling-only)
 - [Core States (`CoreStateful` only)](#core-states-corestateful-only)
 - [Interceptors](#interceptors)
   - [Life-cycle Interceptors](#life-cycle-interceptors)
+- [Preview support (internal)](#preview-support-internal)
 
 <!-- mtoc-end -->
 </details>
@@ -534,47 +534,6 @@ a `Promise<void>`.
 Releases singleton ownership for stateful runtime usage. This is intended for explicit teardown
 paths, such as tests or hot-reload workflows. This method expects no arguments and returns no value.
 
-### `registerPreviewPanel` (preview tooling only)
-
-Registers a preview consumer object and exposes internal signal references used by first-party
-preview tooling.
-
-Arguments:
-
-- `previewPanel`: Required object that receives symbol-keyed signal bridge values
-
-Returns:
-
-- `void`
-
-Bridge symbols:
-
-- `PREVIEW_PANEL_SIGNALS_SYMBOL`: key used to expose internal `signals`
-- `PREVIEW_PANEL_SIGNAL_FNS_SYMBOL`: key used to expose internal `signalFns`
-
-Example:
-
-```ts
-import {
-  PREVIEW_PANEL_SIGNAL_FNS_SYMBOL,
-  PREVIEW_PANEL_SIGNALS_SYMBOL,
-  type PreviewPanelSignalObject,
-} from '@contentful/optimization-core'
-
-const previewBridge: PreviewPanelSignalObject = {}
-optimization.registerPreviewPanel(previewBridge)
-
-const signals = previewBridge[PREVIEW_PANEL_SIGNALS_SYMBOL]
-const signalFns = previewBridge[PREVIEW_PANEL_SIGNAL_FNS_SYMBOL]
-```
-
-> [!IMPORTANT]
->
-> This method intentionally exposes mutable internal signals for preview tooling. The Web and React
-> Native preview panels are tightly coupled by design and rely on this bridge (plus state
-> interceptors) to apply immediate local overrides without network round-trips. This coupling is
-> deliberate and necessary for preview functionality.
-
 ## Core States (`CoreStateful` only)
 
 `states` is available on `CoreStateful` and exposes signal-backed observables for runtime state.
@@ -661,3 +620,16 @@ optimization.interceptors.event((event) => {
 >
 > Interceptors are intended to enable low-level interoperability; to simply read and react to
 > Optimization SDK events, use the `states` observables.
+
+## Preview support (internal)
+
+The `@contentful/optimization-core/preview-support` entry point and the `registerPreviewPanel`
+method on `CoreStateful` exist solely to back the first-party Contentful preview panel across
+platforms. They are **not** part of the public Core SDK surface and are not intended for direct use
+by applications or third-party SDKs. They live in this package because the override state machine is
+core to that cross-platform preview functionality and must sit alongside the SDK's internal signals
+and interceptors.
+
+If you are building on the Optimization SDKs, use your platform SDK's preview panel component rather
+than these primitives. For internal documentation of the toolkit, including `registerPreviewPanel`,
+see [`src/preview-support/README.md`](./src/preview-support/README.md).
diff --git a/packages/universal/core-sdk/package.json b/packages/universal/core-sdk/package.json
index d34a97e7..1f067cd3 100644
--- a/packages/universal/core-sdk/package.json
+++ b/packages/universal/core-sdk/package.json
@@ -72,6 +72,16 @@
         "default": "./dist/api-schemas.cjs"
       }
     },
+    "./preview-support": {
+      "import": {
+        "types": "./dist/preview-support.d.mts",
+        "default": "./dist/preview-support.mjs"
+      },
+      "require": {
+        "types": "./dist/preview-support.d.cts",
+        "default": "./dist/preview-support.cjs"
+      }
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -81,7 +91,9 @@
     "bundleSize": {
       "gzipBudgets": {
         "index.cjs": 13500,
-        "index.mjs": 12250
+        "index.mjs": 12250,
+        "preview-support.cjs": 6500,
+        "preview-support.mjs": 5500
       }
     }
   },
diff --git a/packages/universal/core-sdk/rslib.config.ts b/packages/universal/core-sdk/rslib.config.ts
index c8d35757..836b8860 100644
--- a/packages/universal/core-sdk/rslib.config.ts
+++ b/packages/universal/core-sdk/rslib.config.ts
@@ -23,6 +23,7 @@ export default defineConfig({
       symbols: './src/symbols.ts',
       'api-client': './src/api-client.ts',
       'api-schemas': './src/api-schemas.ts',
+      'preview-support': './src/preview-support/index.ts',
     },
     tsconfigPath: './tsconfig.build.json',
     decorators: { version: '2022-03' }, // stage-3 decorators
diff --git a/packages/universal/core-sdk/rstest.config.ts b/packages/universal/core-sdk/rstest.config.ts
index ce766cf0..f0da1942 100644
--- a/packages/universal/core-sdk/rstest.config.ts
+++ b/packages/universal/core-sdk/rstest.config.ts
@@ -15,7 +15,7 @@ export default defineConfig({
   testEnvironment: 'node',
   setupFiles: ['src/test/setup.ts'],
   coverage: {
-    exclude: ['**/test/*'],
+    exclude: ['**/test/*', '**/*.md'],
     include: ['src/**/*'],
     reporters: coverageReporters,
   },
diff --git a/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.audienceBaseline.test.ts b/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.audienceBaseline.test.ts
new file mode 100644
index 00000000..c94e979b
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.audienceBaseline.test.ts
@@ -0,0 +1,146 @@
+import type {
+  OptimizationData,
+  Profile,
+  SelectedOptimizationArray,
+} from '@contentful/optimization-api-client/api-schemas'
+import { signal, type Signal } from '@preact/signals-core'
+import { InterceptorManager } from '../lib/interceptor'
+import { PreviewOverrideManager } from './PreviewOverrideManager'
+import { BASELINE, makeOptimizationData } from './PreviewOverrideManager.test-utils'
+
+function makeProfile(qualifiedAudiences: string[]): Profile {
+  const { profile } = makeOptimizationData(BASELINE)
+  return { ...profile, audiences: qualifiedAudiences }
+}
+
+interface Harness {
+  manager: PreviewOverrideManager
+  profileSignal: Signal<Profile | undefined>
+  selectedOptimizations: Signal<SelectedOptimizationArray | undefined>
+}
+
+function createHarness(initialProfile: Profile | undefined): Harness {
+  const profileSignal = signal<Profile | undefined>(initialProfile)
+  const selectedOptimizations = signal<SelectedOptimizationArray | undefined>(BASELINE)
+  const stateInterceptors = new InterceptorManager<OptimizationData>()
+  const manager = new PreviewOverrideManager({
+    selectedOptimizations,
+    profile: profileSignal,
+    stateInterceptors,
+    onOverridesChanged: rs.fn(),
+  })
+  return { manager, profileSignal, selectedOptimizations }
+}
+
+describe('PreviewOverrideManager — audience qualification baseline', () => {
+  let manager: PreviewOverrideManager | undefined
+
+  afterEach(() => {
+    manager?.destroy()
+    manager = undefined
+  })
+
+  it('starts empty when no audience has been overridden yet', () => {
+    const h = createHarness(makeProfile(['aud-1']))
+    manager = h.manager
+    expect(manager.getBaselineAudienceQualifications()).toEqual({})
+  })
+
+  it('activateAudience captures profile.audiences membership as the snapshot', () => {
+    const h = createHarness(makeProfile(['aud-qualified']))
+    manager = h.manager
+
+    manager.activateAudience('aud-qualified', ['exp-1'])
+    manager.activateAudience('aud-unqualified', ['exp-2'])
+
+    expect(manager.getBaselineAudienceQualifications()).toEqual({
+      'aud-qualified': true,
+      'aud-unqualified': false,
+    })
+  })
+
+  it('deactivateAudience captures profile.audiences membership as the snapshot', () => {
+    const h = createHarness(makeProfile(['aud-1']))
+    manager = h.manager
+
+    manager.deactivateAudience('aud-1', ['exp-1'])
+    expect(manager.getBaselineAudienceQualifications()).toEqual({ 'aud-1': true })
+  })
+
+  it('does not update the snapshot on subsequent overrides of the same audience', () => {
+    const h = createHarness(makeProfile([])) // aud-1 initially unqualified
+    manager = h.manager
+
+    manager.activateAudience('aud-1', ['exp-1'])
+    expect(manager.getBaselineAudienceQualifications()['aud-1']).toBe(false)
+
+    // Even if profile membership later changes, or the user flips their override
+    // several times, the snapshot reflects the *original* pre-override state.
+    h.profileSignal.value = makeProfile(['aud-1'])
+    manager.deactivateAudience('aud-1', ['exp-1'])
+    manager.activateAudience('aud-1', ['exp-1'])
+
+    expect(manager.getBaselineAudienceQualifications()['aud-1']).toBe(false)
+  })
+
+  it('resetAudienceOverride removes the snapshot entry for that audience', () => {
+    const h = createHarness(makeProfile(['aud-1']))
+    manager = h.manager
+
+    manager.activateAudience('aud-1', ['exp-1'])
+    manager.activateAudience('aud-2', ['exp-2'])
+    expect(manager.getBaselineAudienceQualifications()).toEqual({
+      'aud-1': true,
+      'aud-2': false,
+    })
+
+    manager.resetAudienceOverride('aud-1')
+    expect(manager.getBaselineAudienceQualifications()).toEqual({ 'aud-2': false })
+  })
+
+  it('resetAll clears all snapshots', () => {
+    const h = createHarness(makeProfile(['aud-1']))
+    manager = h.manager
+
+    manager.activateAudience('aud-1', ['exp-1'])
+    manager.activateAudience('aud-2', ['exp-2'])
+    expect(Object.keys(manager.getBaselineAudienceQualifications())).toHaveLength(2)
+
+    manager.resetAll()
+    expect(manager.getBaselineAudienceQualifications()).toEqual({})
+  })
+
+  it('destroy clears all snapshots', () => {
+    const h = createHarness(makeProfile(['aud-1']))
+    manager = h.manager
+
+    manager.activateAudience('aud-1', ['exp-1'])
+    manager.destroy()
+
+    expect(manager.getBaselineAudienceQualifications()).toEqual({})
+    manager = undefined // prevent afterEach double-destroy
+  })
+
+  it('treats profile.value = undefined as "not qualified"', () => {
+    const h = createHarness(undefined)
+    manager = h.manager
+
+    manager.activateAudience('aud-1', ['exp-1'])
+    expect(manager.getBaselineAudienceQualifications()).toEqual({ 'aud-1': false })
+  })
+
+  it('is a no-op when no profile signal was provided (backward compat)', () => {
+    const selectedOptimizations = signal<SelectedOptimizationArray | undefined>(BASELINE)
+    const stateInterceptors = new InterceptorManager<OptimizationData>()
+    const mgr = new PreviewOverrideManager({
+      selectedOptimizations,
+      stateInterceptors,
+      onOverridesChanged: rs.fn(),
+    })
+
+    mgr.activateAudience('aud-1', ['exp-1'])
+    expect(mgr.getBaselineAudienceQualifications()).toEqual({})
+
+    mgr.destroy()
+  })
+})
diff --git a/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.scenarios.test.ts b/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.scenarios.test.ts
new file mode 100644
index 00000000..436a2644
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.scenarios.test.ts
@@ -0,0 +1,170 @@
+import type {
+  OptimizationData,
+  SelectedOptimizationArray,
+} from '@contentful/optimization-api-client/api-schemas'
+import { signal } from '@preact/signals-core'
+import { InterceptorManager } from '../lib/interceptor'
+import { PreviewOverrideManager } from './PreviewOverrideManager'
+import {
+  BASELINE,
+  makeOptimizationData,
+  type InterceptorFn,
+} from './PreviewOverrideManager.test-utils'
+
+let selectedOptimizations: ReturnType<typeof signal<SelectedOptimizationArray | undefined>>
+let stateInterceptors: InterceptorManager<OptimizationData>
+let onOverridesChanged: ReturnType<typeof rs.fn>
+let capturedInterceptor: InterceptorFn | undefined
+let manager: PreviewOverrideManager | undefined
+
+function createManager(): PreviewOverrideManager {
+  selectedOptimizations = signal<SelectedOptimizationArray | undefined>(BASELINE)
+  stateInterceptors = new InterceptorManager<OptimizationData>()
+  capturedInterceptor = undefined
+  rs.spyOn(stateInterceptors, 'add').mockImplementation((fn: InterceptorFn) => {
+    capturedInterceptor = fn
+    return 0
+  })
+  rs.spyOn(stateInterceptors, 'remove').mockImplementation(() => true)
+  onOverridesChanged = rs.fn()
+  manager = new PreviewOverrideManager({
+    selectedOptimizations,
+    stateInterceptors,
+    onOverridesChanged,
+  })
+  return manager
+}
+
+function invokeInterceptor(): InterceptorFn {
+  if (!capturedInterceptor) throw new Error('Interceptor not captured')
+  return capturedInterceptor
+}
+
+function sv(): SelectedOptimizationArray {
+  const v = selectedOptimizations.value
+  if (!v) throw new Error('Signal value is unexpectedly undefined')
+  return v
+}
+
+describe('PreviewOverrideManager — scenarios & edge cases', () => {
+  afterEach(() => {
+    manager?.destroy()
+    manager = undefined
+  })
+
+  describe('real-world scenarios', () => {
+    it('selecting experiences for an audience the user does not qualify for', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-X', ['exp-99', 'exp-100'])
+      expect(sv()).toHaveLength(BASELINE.length + 2)
+      expect(sv().find((s) => s.experienceId === 'exp-99')).toEqual({
+        experienceId: 'exp-99',
+        variantIndex: 1,
+        variants: {},
+      })
+      expect(sv().find((s) => s.experienceId === 'exp-100')).toEqual({
+        experienceId: 'exp-100',
+        variantIndex: 1,
+        variants: {},
+      })
+      expect(mgr.getOverrides().audiences['aud-X']?.isActive).toBe(true)
+      expect(mgr.getBaselineSelectedOptimizations()).toEqual(BASELINE)
+    })
+
+    it('user removes themselves from a selected experience', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-X', ['exp-99'])
+      expect(sv().find((s) => s.experienceId === 'exp-99')).toBeDefined()
+      mgr.resetAudienceOverride('aud-X')
+      expect(sv()).toHaveLength(BASELINE.length)
+      expect(sv().find((s) => s.experienceId === 'exp-99')).toBeUndefined()
+      expect(mgr.getOverrides()).toEqual({ audiences: {}, selectedOptimizations: {} })
+    })
+
+    it('API refresh arrives while overrides are active', async () => {
+      const mgr = createManager()
+      mgr.setVariantOverride('exp-1', 5)
+      const fresh: SelectedOptimizationArray = [
+        { experienceId: 'exp-1', variantIndex: 1, variants: { b1: 'v1' }, sticky: false },
+        { experienceId: 'exp-2', variantIndex: 2, variants: { b2: 'v2' }, sticky: false },
+        { experienceId: 'exp-4', variantIndex: 0, variants: { b4: 'v4' }, sticky: false },
+      ]
+      const result = await invokeInterceptor()(makeOptimizationData(fresh))
+      expect(
+        result.selectedOptimizations.find((s) => s.experienceId === 'exp-1')?.variantIndex,
+      ).toBe(5)
+      expect(
+        result.selectedOptimizations.find((s) => s.experienceId === 'exp-2')?.variantIndex,
+      ).toBe(2)
+      expect(
+        result.selectedOptimizations.find((s) => s.experienceId === 'exp-4')?.variantIndex,
+      ).toBe(0)
+      expect(mgr.getBaselineSelectedOptimizations()).toEqual(fresh)
+      mgr.resetAll()
+      expect(selectedOptimizations.value).toEqual(fresh)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('multiple audiences with overlapping experience IDs', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-A', ['exp-1', 'exp-2'])
+      mgr.activateAudience('aud-B', ['exp-2', 'exp-3'])
+      expect(mgr.getOverrides().selectedOptimizations['exp-2']?.variantIndex).toBe(1)
+      mgr.resetAudienceOverride('aud-A')
+      const overrides = mgr.getOverrides()
+      expect(overrides.selectedOptimizations['exp-1']).toBeUndefined()
+      expect(overrides.selectedOptimizations['exp-2']).toBeUndefined()
+      expect(overrides.selectedOptimizations['exp-3']?.variantIndex).toBe(1)
+      expect(overrides.audiences['aud-B']).toBeDefined()
+    })
+
+    it('re-activation after reset restores overrides', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-1', ['exp-99'])
+      mgr.resetAudienceOverride('aud-1')
+      mgr.activateAudience('aud-1', ['exp-99'])
+      expect(sv().find((s) => s.experienceId === 'exp-99')).toEqual({
+        experienceId: 'exp-99',
+        variantIndex: 1,
+        variants: {},
+      })
+      expect(mgr.getOverrides().audiences['aud-1']?.isActive).toBe(true)
+    })
+
+    it('activate then deactivate same audience updates isActive and variant indices', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-1', ['exp-1'])
+      expect(mgr.getOverrides().audiences['aud-1']?.isActive).toBe(true)
+      expect(mgr.getOverrides().selectedOptimizations['exp-1']?.variantIndex).toBe(1)
+      mgr.deactivateAudience('aud-1', ['exp-1'])
+      expect(mgr.getOverrides().audiences['aud-1']?.isActive).toBe(false)
+      expect(mgr.getOverrides().selectedOptimizations['exp-1']?.variantIndex).toBe(0)
+    })
+
+    it('undefined baseline -- syncOverridesToSignal uses empty array fallback', () => {
+      const sig = signal<SelectedOptimizationArray | undefined>(undefined)
+      const interceptors = new InterceptorManager<OptimizationData>()
+      const mgr = new PreviewOverrideManager({
+        selectedOptimizations: sig,
+        stateInterceptors: interceptors,
+        onOverridesChanged: rs.fn(),
+      })
+      mgr.setVariantOverride('exp-1', 2)
+      expect(sig.value).toEqual([{ experienceId: 'exp-1', variantIndex: 2, variants: {} }])
+      mgr.destroy()
+    })
+
+    it('onOverridesChanged is invoked on every mutation', () => {
+      const mgr = createManager()
+      expect(() => {
+        mgr.activateAudience('aud-1', ['exp-1'])
+        mgr.deactivateAudience('aud-1', ['exp-1'])
+        mgr.setVariantOverride('exp-1', 3)
+        mgr.resetOptimizationOverride('exp-1')
+        mgr.resetAll()
+      }).not.toThrow()
+      expect(onOverridesChanged).toHaveBeenCalled()
+    })
+  })
+})
diff --git a/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.test-utils.ts b/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.test-utils.ts
new file mode 100644
index 00000000..3413ebb7
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.test-utils.ts
@@ -0,0 +1,44 @@
+import type {
+  OptimizationData,
+  SelectedOptimizationArray,
+} from '@contentful/optimization-api-client/api-schemas'
+
+export const BASELINE: SelectedOptimizationArray = [
+  { experienceId: 'exp-1', variantIndex: 1, variants: { b1: 'v1' }, sticky: false },
+  { experienceId: 'exp-2', variantIndex: 2, variants: { b2: 'v2' }, sticky: false },
+  { experienceId: 'exp-3', variantIndex: 0, variants: {}, sticky: false },
+]
+
+export function makeOptimizationData(so: SelectedOptimizationArray): OptimizationData {
+  return {
+    profile: {
+      id: 'p1',
+      stableId: 'p1',
+      random: 0.5,
+      audiences: [],
+      traits: {},
+      location: {},
+      session: {
+        id: 's1',
+        isReturningVisitor: false,
+        count: 1,
+        activeSessionLength: 0,
+        averageSessionLength: 0,
+        landingPage: {
+          url: 'https://example.test/',
+          referrer: '',
+          query: {},
+          search: '',
+          path: '/',
+          title: '',
+        },
+      },
+    },
+    selectedOptimizations: so,
+    changes: [],
+  }
+}
+
+export type InterceptorFn = (
+  data: Readonly<OptimizationData>,
+) => OptimizationData | Promise<OptimizationData>
diff --git a/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.test.ts b/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.test.ts
new file mode 100644
index 00000000..0bdbfc54
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.test.ts
@@ -0,0 +1,411 @@
+import type {
+  OptimizationData,
+  SelectedOptimizationArray,
+} from '@contentful/optimization-api-client/api-schemas'
+import { signal } from '@preact/signals-core'
+import { InterceptorManager } from '../lib/interceptor'
+import { PreviewOverrideManager } from './PreviewOverrideManager'
+import {
+  BASELINE,
+  makeOptimizationData,
+  type InterceptorFn,
+} from './PreviewOverrideManager.test-utils'
+
+let selectedOptimizations: ReturnType<typeof signal<SelectedOptimizationArray | undefined>>
+let stateInterceptors: InterceptorManager<OptimizationData>
+let addSpy: ReturnType<typeof rs.spyOn>
+let removeSpy: ReturnType<typeof rs.spyOn>
+let onOverridesChanged: ReturnType<typeof rs.fn>
+let capturedInterceptor: InterceptorFn | undefined
+let manager: PreviewOverrideManager | undefined
+
+const REGISTERED_ID = 42
+
+function createManager(): PreviewOverrideManager {
+  selectedOptimizations = signal<SelectedOptimizationArray | undefined>(BASELINE)
+  stateInterceptors = new InterceptorManager<OptimizationData>()
+  capturedInterceptor = undefined
+  addSpy = rs.spyOn(stateInterceptors, 'add').mockImplementation((fn: InterceptorFn) => {
+    capturedInterceptor = fn
+    return REGISTERED_ID
+  })
+  removeSpy = rs.spyOn(stateInterceptors, 'remove').mockImplementation(() => true)
+  onOverridesChanged = rs.fn()
+  manager = new PreviewOverrideManager({
+    selectedOptimizations,
+    stateInterceptors,
+    onOverridesChanged,
+  })
+  return manager
+}
+
+function invokeInterceptor(): InterceptorFn {
+  if (!capturedInterceptor) throw new Error('Interceptor not captured')
+  return capturedInterceptor
+}
+
+function sv(): SelectedOptimizationArray {
+  const v = selectedOptimizations.value
+  if (!v) throw new Error('Signal value is unexpectedly undefined')
+  return v
+}
+
+describe('PreviewOverrideManager', () => {
+  afterEach(() => {
+    manager?.destroy()
+    manager = undefined
+  })
+
+  describe('constructor', () => {
+    it('captures initial signal value as baseline when signal has data', () => {
+      const mgr = createManager()
+      expect(mgr.getBaselineSelectedOptimizations()).toEqual(BASELINE)
+    })
+
+    it('leaves baseline null when initial signal is undefined', () => {
+      const sig = signal<SelectedOptimizationArray | undefined>(undefined)
+      const interceptors = new InterceptorManager<OptimizationData>()
+      const mgr = new PreviewOverrideManager({
+        selectedOptimizations: sig,
+        stateInterceptors: interceptors,
+        onOverridesChanged: rs.fn(),
+      })
+      expect(mgr.getBaselineSelectedOptimizations()).toBeNull()
+      mgr.destroy()
+    })
+
+    it('registers a state interceptor and starts with empty overrides', () => {
+      const mgr = createManager()
+      expect(addSpy).toHaveBeenCalledTimes(1)
+      expect(mgr.getOverrides()).toEqual({ audiences: {}, selectedOptimizations: {} })
+      expect(onOverridesChanged).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('activateAudience', () => {
+    it('sets variant index 1 for all provided experience IDs', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-1', ['exp-1', 'exp-2'])
+      const overrides = mgr.getOverrides()
+      expect(overrides.audiences['aud-1']).toEqual({
+        audienceId: 'aud-1',
+        isActive: true,
+        source: 'manual',
+        experienceIds: ['exp-1', 'exp-2'],
+      })
+      expect(overrides.selectedOptimizations['exp-1']).toEqual({
+        experienceId: 'exp-1',
+        variantIndex: 1,
+      })
+      expect(overrides.selectedOptimizations['exp-2']).toEqual({
+        experienceId: 'exp-2',
+        variantIndex: 1,
+      })
+      expect(sv().find((s) => s.experienceId === 'exp-1')?.variantIndex).toBe(1)
+      expect(sv().find((s) => s.experienceId === 'exp-2')?.variantIndex).toBe(1)
+    })
+
+    it('appends entries for experiences NOT in the API baseline', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-new', ['exp-99', 'exp-100'])
+      expect(sv()).toHaveLength(BASELINE.length + 2)
+      expect(sv().find((s) => s.experienceId === 'exp-99')).toEqual({
+        experienceId: 'exp-99',
+        variantIndex: 1,
+        variants: {},
+      })
+      expect(sv().find((s) => s.experienceId === 'exp-100')).toEqual({
+        experienceId: 'exp-100',
+        variantIndex: 1,
+        variants: {},
+      })
+    })
+
+    it('with empty experience list records audience but does not sync signal', () => {
+      const mgr = createManager()
+      const original = selectedOptimizations.value
+      mgr.activateAudience('aud-empty', [])
+      expect(mgr.getOverrides().audiences['aud-empty']).toEqual({
+        audienceId: 'aud-empty',
+        isActive: true,
+        source: 'manual',
+        experienceIds: [],
+      })
+      expect(selectedOptimizations.value).toBe(original)
+      expect(onOverridesChanged).toHaveBeenCalledTimes(1)
+    })
+
+    it('invokes onOverridesChanged with updated state', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-1', ['exp-1'])
+      expect(onOverridesChanged).toHaveBeenCalledTimes(1)
+      expect(onOverridesChanged).toHaveBeenCalledWith(
+        expect.objectContaining({
+          audiences: expect.objectContaining({
+            'aud-1': expect.objectContaining({ isActive: true }),
+          }),
+        }),
+      )
+    })
+  })
+
+  describe('deactivateAudience', () => {
+    it('sets variant index 0 (baseline) for all provided experience IDs', () => {
+      const mgr = createManager()
+      mgr.deactivateAudience('aud-1', ['exp-1', 'exp-2'])
+      const overrides = mgr.getOverrides()
+      expect(overrides.audiences['aud-1']).toEqual({
+        audienceId: 'aud-1',
+        isActive: false,
+        source: 'manual',
+        experienceIds: ['exp-1', 'exp-2'],
+      })
+      expect(overrides.selectedOptimizations['exp-1']?.variantIndex).toBe(0)
+      expect(overrides.selectedOptimizations['exp-2']?.variantIndex).toBe(0)
+      expect(sv().find((s) => s.experienceId === 'exp-1')?.variantIndex).toBe(0)
+      expect(sv().find((s) => s.experienceId === 'exp-2')?.variantIndex).toBe(0)
+    })
+
+    it('with empty experience list records audience as inactive without syncing signal', () => {
+      const mgr = createManager()
+      const original = selectedOptimizations.value
+      mgr.deactivateAudience('aud-empty', [])
+      expect(mgr.getOverrides().audiences['aud-empty']?.isActive).toBe(false)
+      expect(selectedOptimizations.value).toBe(original)
+      expect(onOverridesChanged).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('setVariantOverride', () => {
+    it('overrides an existing baseline experience variant', () => {
+      const mgr = createManager()
+      mgr.setVariantOverride('exp-1', 3)
+      expect(mgr.getOverrides().selectedOptimizations['exp-1']).toEqual({
+        experienceId: 'exp-1',
+        variantIndex: 3,
+      })
+      expect(sv().find((s) => s.experienceId === 'exp-1')?.variantIndex).toBe(3)
+      expect(sv().find((s) => s.experienceId === 'exp-2')?.variantIndex).toBe(2)
+      expect(sv().find((s) => s.experienceId === 'exp-3')?.variantIndex).toBe(0)
+      expect(
+        mgr.getBaselineSelectedOptimizations()?.find((s) => s.experienceId === 'exp-1')
+          ?.variantIndex,
+      ).toBe(1)
+    })
+
+    it('appends entry for experience not in baseline', () => {
+      const mgr = createManager()
+      mgr.setVariantOverride('exp-new', 2)
+      expect(sv()).toHaveLength(BASELINE.length + 1)
+      expect(sv().find((s) => s.experienceId === 'exp-new')).toEqual({
+        experienceId: 'exp-new',
+        variantIndex: 2,
+        variants: {},
+      })
+    })
+
+    it('multiple sequential overrides accumulate and can be overwritten', () => {
+      const mgr = createManager()
+      mgr.setVariantOverride('exp-1', 3)
+      mgr.setVariantOverride('exp-2', 5)
+      expect(mgr.getOverrides().selectedOptimizations['exp-1']?.variantIndex).toBe(3)
+      expect(mgr.getOverrides().selectedOptimizations['exp-2']?.variantIndex).toBe(5)
+      mgr.setVariantOverride('exp-1', 7)
+      expect(mgr.getOverrides().selectedOptimizations['exp-1']?.variantIndex).toBe(7)
+      expect(sv().find((s) => s.experienceId === 'exp-1')?.variantIndex).toBe(7)
+      expect(onOverridesChanged).toHaveBeenCalledTimes(3)
+    })
+
+    it('derives signal from baseline, not from stale signal value', () => {
+      const mgr = createManager()
+      mgr.setVariantOverride('exp-1', 3)
+      selectedOptimizations.value = []
+      mgr.setVariantOverride('exp-2', 5)
+      expect(sv().length).toBeGreaterThanOrEqual(BASELINE.length)
+      expect(sv().find((s) => s.experienceId === 'exp-1')?.variantIndex).toBe(3)
+      expect(sv().find((s) => s.experienceId === 'exp-2')?.variantIndex).toBe(5)
+      expect(sv().find((s) => s.experienceId === 'exp-3')?.variantIndex).toBe(0)
+    })
+  })
+
+  describe('resetOptimizationOverride', () => {
+    it('removes a single experience override and recomputes signal from baseline', () => {
+      const mgr = createManager()
+      mgr.setVariantOverride('exp-1', 3)
+      mgr.setVariantOverride('exp-2', 5)
+      mgr.resetOptimizationOverride('exp-1')
+      expect(mgr.getOverrides().selectedOptimizations['exp-1']).toBeUndefined()
+      expect(mgr.getOverrides().selectedOptimizations['exp-2']?.variantIndex).toBe(5)
+      expect(sv().find((s) => s.experienceId === 'exp-1')?.variantIndex).toBe(1)
+      expect(sv().find((s) => s.experienceId === 'exp-2')?.variantIndex).toBe(5)
+    })
+
+    it('resetting a non-existent override is a no-op (does not throw)', () => {
+      const mgr = createManager()
+      expect(() => {
+        mgr.resetOptimizationOverride('nonexistent')
+      }).not.toThrow()
+      expect(onOverridesChanged).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('resetAudienceOverride', () => {
+    it('removes audience and all its associated experience overrides', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-1', ['exp-1', 'exp-2'])
+      mgr.resetAudienceOverride('aud-1')
+      expect(mgr.getOverrides()).toEqual({ audiences: {}, selectedOptimizations: {} })
+      expect(sv().find((s) => s.experienceId === 'exp-1')?.variantIndex).toBe(1)
+      expect(sv().find((s) => s.experienceId === 'exp-2')?.variantIndex).toBe(2)
+    })
+
+    it('only removes experiences belonging to the reset audience, preserves others', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-1', ['exp-1'])
+      mgr.setVariantOverride('exp-2', 5)
+      mgr.resetAudienceOverride('aud-1')
+      expect(mgr.getOverrides().selectedOptimizations['exp-1']).toBeUndefined()
+      expect(mgr.getOverrides().selectedOptimizations['exp-2']?.variantIndex).toBe(5)
+      expect(mgr.getOverrides().audiences['aud-1']).toBeUndefined()
+    })
+
+    it('resetting audience with no stored experience IDs still notifies', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-empty', [])
+      onOverridesChanged.mockClear()
+      mgr.resetAudienceOverride('aud-empty')
+      expect(onOverridesChanged).toHaveBeenCalledTimes(1)
+      expect(mgr.getOverrides().audiences).toEqual({})
+    })
+
+    it('resetting a non-existent audience is safe', () => {
+      const mgr = createManager()
+      expect(() => {
+        mgr.resetAudienceOverride('nonexistent')
+      }).not.toThrow()
+      expect(onOverridesChanged).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('resetAll', () => {
+    it('clears all overrides and restores signal to baseline', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-1', ['exp-1'])
+      mgr.setVariantOverride('exp-2', 5)
+      mgr.resetAll()
+      expect(mgr.getOverrides()).toEqual({ audiences: {}, selectedOptimizations: {} })
+      expect(selectedOptimizations.value).toEqual(BASELINE)
+    })
+
+    it('handles resetAll when baseline is null (signal initially undefined)', () => {
+      const sig = signal<SelectedOptimizationArray | undefined>(undefined)
+      const interceptors = new InterceptorManager<OptimizationData>()
+      const mgr = new PreviewOverrideManager({
+        selectedOptimizations: sig,
+        stateInterceptors: interceptors,
+        onOverridesChanged: rs.fn(),
+      })
+      mgr.setVariantOverride('exp-1', 1)
+      expect(() => {
+        mgr.resetAll()
+      }).not.toThrow()
+      expect(mgr.getOverrides()).toEqual({ audiences: {}, selectedOptimizations: {} })
+      mgr.destroy()
+    })
+  })
+
+  describe('destroy', () => {
+    it('removes the state interceptor and clears all internal state', () => {
+      const mgr = createManager()
+      mgr.activateAudience('aud-1', ['exp-1'])
+      onOverridesChanged.mockClear()
+      mgr.destroy()
+      expect(removeSpy).toHaveBeenCalledTimes(1)
+      expect(removeSpy).toHaveBeenCalledWith(REGISTERED_ID)
+      expect(mgr.getOverrides()).toEqual({ audiences: {}, selectedOptimizations: {} })
+      expect(mgr.getBaselineSelectedOptimizations()).toBeNull()
+      expect(onOverridesChanged).not.toHaveBeenCalled()
+    })
+
+    it('calling destroy twice does not call remove twice', () => {
+      const mgr = createManager()
+      mgr.destroy()
+      mgr.destroy()
+      expect(removeSpy).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('state interceptor (API refresh)', () => {
+    const NEW_API: SelectedOptimizationArray = [
+      { experienceId: 'exp-1', variantIndex: 1, variants: { b1: 'v1' }, sticky: false },
+      { experienceId: 'exp-2', variantIndex: 2, variants: { b2: 'v2' }, sticky: false },
+      { experienceId: 'exp-4', variantIndex: 0, variants: { b4: 'v4' }, sticky: false },
+    ]
+
+    it('caches incoming API data as new baseline', () => {
+      const mgr = createManager()
+      invokeInterceptor()(makeOptimizationData(NEW_API))
+      expect(mgr.getBaselineSelectedOptimizations()).toEqual(NEW_API)
+    })
+
+    it('passes through unchanged when no overrides are active', async () => {
+      createManager()
+      const input = makeOptimizationData(NEW_API)
+      const result = await invokeInterceptor()(input)
+      expect(result).not.toBe(input)
+      expect(result.selectedOptimizations).toBe(input.selectedOptimizations)
+    })
+
+    it('merges active overrides into incoming API data', async () => {
+      const mgr = createManager()
+      mgr.setVariantOverride('exp-1', 7)
+      const result = await invokeInterceptor()(makeOptimizationData(NEW_API))
+      expect(
+        result.selectedOptimizations.find((s) => s.experienceId === 'exp-1')?.variantIndex,
+      ).toBe(7)
+      expect(
+        result.selectedOptimizations.find((s) => s.experienceId === 'exp-2')?.variantIndex,
+      ).toBe(2)
+    })
+
+    it('appends overridden experiences not in API data', async () => {
+      const mgr = createManager()
+      mgr.setVariantOverride('exp-new', 3)
+      const result = await invokeInterceptor()(makeOptimizationData(NEW_API))
+      expect(result.selectedOptimizations).toHaveLength(NEW_API.length + 1)
+      expect(result.selectedOptimizations.find((s) => s.experienceId === 'exp-new')).toEqual({
+        experienceId: 'exp-new',
+        variantIndex: 3,
+        variants: {},
+      })
+    })
+
+    it('updates baseline so future resets use fresh API data', () => {
+      const mgr = createManager()
+      mgr.setVariantOverride('exp-1', 7)
+      invokeInterceptor()(makeOptimizationData(NEW_API))
+      mgr.resetAll()
+      expect(selectedOptimizations.value).toEqual(NEW_API)
+    })
+
+    it('invokes onOverridesChanged after each API refresh', async () => {
+      const mgr = createManager()
+      onOverridesChanged.mockClear()
+
+      // Refresh with no overrides present — callback should still fire so
+      // consumers learn the underlying data changed.
+      await invokeInterceptor()(makeOptimizationData(NEW_API))
+      expect(onOverridesChanged).toHaveBeenCalledTimes(1)
+      expect(onOverridesChanged).toHaveBeenLastCalledWith(mgr.getOverrides())
+
+      // Apply an override, clear the mock, then run another refresh and
+      // confirm the callback fires again with the current overrides snapshot.
+      mgr.setVariantOverride('exp-1', 9)
+      onOverridesChanged.mockClear()
+
+      await invokeInterceptor()(makeOptimizationData(NEW_API))
+      expect(onOverridesChanged).toHaveBeenCalledTimes(1)
+      expect(onOverridesChanged).toHaveBeenLastCalledWith(mgr.getOverrides())
+    })
+  })
+})
diff --git a/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.ts b/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.ts
new file mode 100644
index 00000000..66cd1cc5
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/PreviewOverrideManager.ts
@@ -0,0 +1,368 @@
+import type {
+  OptimizationData,
+  Profile,
+  SelectedOptimizationArray,
+} from '@contentful/optimization-api-client/api-schemas'
+import { createScopedLogger } from '@contentful/optimization-api-client/logger'
+import type { Signal } from '@preact/signals-core'
+import type { InterceptorManager } from '../lib/interceptor'
+import { applyOptimizationOverrides } from './applyOptimizationOverrides'
+import type { OptimizationOverride, OverrideState } from './types'
+
+const logger = createScopedLogger('PreviewOverrides')
+
+/**
+ * Subset of {@link InterceptorManager} consumed by the preview override
+ * manager. Picking only the public methods (`add` / `remove`) avoids the
+ * nominal-typing mismatch that would otherwise arise when a consumer passes
+ * an `InterceptorManager` resolved from one bundle (e.g. the package root)
+ * into a `PreviewOverrideManager` typed via a different bundle (e.g. the
+ * `./preview-support` entry point), since `InterceptorManager`'s `private`
+ * fields are emitted into each bundled `.d.ts` separately.
+ */
+type StateInterceptorAccess<T> = Pick<InterceptorManager<T>, 'add' | 'remove'>
+
+const INITIAL_STATE: OverrideState = {
+  audiences: {},
+  selectedOptimizations: {},
+}
+
+/**
+ * Configuration for {@link PreviewOverrideManager}.
+ *
+ * @public
+ */
+export interface PreviewOverrideManagerConfig {
+  /** Signal for selected optimizations (variant selections). */
+  selectedOptimizations: Signal<SelectedOptimizationArray | undefined>
+
+  /**
+   * Optional profile signal. When provided, the manager snapshots the user's
+   * natural qualification for each audience (via `profile.audiences.includes(id)`)
+   * on the first override of that audience. Exposed via
+   * {@link PreviewOverrideManager.getBaselineAudienceQualifications} so the preview
+   * panel can surface "was naturally qualified: yes/no" alongside the override.
+   */
+  profile?: Signal<Profile | undefined>
+
+  /** The state interceptor registry to register with. */
+  stateInterceptors: StateInterceptorAccess<OptimizationData>
+
+  /**
+   * Callback invoked whenever override state changes.
+   * RN uses this to trigger setState; the iOS bridge uses it to
+   * notify the native side via a global callback.
+   */
+  onOverridesChanged: (state: Readonly<OverrideState>) => void
+}
+
+/**
+ * Platform-agnostic manager for preview panel overrides.
+ *
+ * Registers a state interceptor that preserves overrides across API refreshes
+ * and provides methods to activate/deactivate audiences and set variant
+ * overrides. Always derives the signal value from a clean API baseline plus
+ * current overrides — never reads from the (possibly stale) signal.
+ *
+ * @remarks
+ * Intended to be wrapped by platform-specific layers:
+ * - React Native: the `useProfileOverrides` hook
+ * - iOS: the JSC bridge override methods
+ *
+ * @public
+ */
+export class PreviewOverrideManager {
+  private baselineSelectedOptimizations: SelectedOptimizationArray | null = null
+  private baselineAudienceQualifications: Record<string, boolean> = {}
+  private overrides: OverrideState = { ...INITIAL_STATE, audiences: {}, selectedOptimizations: {} }
+  private interceptorId: number | null = null
+
+  private readonly selectedOptimizations: Signal<SelectedOptimizationArray | undefined>
+  private readonly profile: Signal<Profile | undefined> | undefined
+  private readonly stateInterceptors: StateInterceptorAccess<OptimizationData>
+  private readonly onOverridesChanged: ((state: Readonly<OverrideState>) => void) | undefined
+
+  constructor(config: PreviewOverrideManagerConfig) {
+    const { selectedOptimizations, profile, stateInterceptors, onOverridesChanged } = config
+    this.selectedOptimizations = selectedOptimizations
+    this.profile = profile
+    this.stateInterceptors = stateInterceptors
+    this.onOverridesChanged = onOverridesChanged
+
+    // Capture current signal state as the initial baseline so we have
+    // data to restore to even if no API calls happen after construction.
+    const { value: initialSelectedOptimizations } = selectedOptimizations
+    if (initialSelectedOptimizations) {
+      this.baselineSelectedOptimizations = initialSelectedOptimizations
+      logger.debug('Captured initial signal state as baseline')
+    }
+
+    // Register state interceptor to preserve overrides when API responses arrive
+    this.interceptorId = config.stateInterceptors.add(
+      (data: Readonly<OptimizationData>): OptimizationData => {
+        // Cache the un-overridden selectedOptimizations as the new baseline
+        const { selectedOptimizations: incoming } = data
+        this.baselineSelectedOptimizations = incoming
+
+        const hasOverrides = Object.keys(this.overrides.selectedOptimizations).length > 0
+        const next = hasOverrides
+          ? {
+              ...data,
+              selectedOptimizations: applyOptimizationOverrides(
+                data.selectedOptimizations,
+                this.overrides.selectedOptimizations,
+              ),
+            }
+          : { ...data }
+
+        if (hasOverrides) logger.debug('Intercepting state update to preserve overrides')
+
+        // Fire the change callback on every API refresh so consumers can pull a
+        // fresh snapshot of derived preview state (audience qualification,
+        // current variant selection, etc.) — not just when an override mutates.
+        this.notifyChanged()
+
+        return next
+      },
+    )
+
+    logger.info('State interceptor registered')
+  }
+
+  // ---------------------------------------------------------------------------
+  // Audience actions
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Activate an audience override and set all associated experiences to
+   * variant index 1 (first non-baseline variant).
+   */
+  activateAudience(audienceId: string, experienceIds: string[]): void {
+    logger.info('Activating audience override:', audienceId)
+    this.setAudienceOverride(audienceId, true, 1, experienceIds)
+  }
+
+  /**
+   * Deactivate an audience override and set all associated experiences to
+   * variant index 0 (baseline).
+   */
+  deactivateAudience(audienceId: string, experienceIds: string[]): void {
+    logger.info('Deactivating audience override:', audienceId)
+    this.setAudienceOverride(audienceId, false, 0, experienceIds)
+  }
+
+  /**
+   * Reset a specific audience override and its associated experience overrides.
+   * Recomputes the signal from the clean baseline.
+   */
+  resetAudienceOverride(audienceId: string): void {
+    logger.info('Resetting audience override:', audienceId)
+
+    const { overrides } = this
+    const { audiences, selectedOptimizations: currentOptOverrides } = overrides
+    const storedExperienceIds = audiences[audienceId]?.experienceIds ?? []
+    const experienceIdSet = new Set(storedExperienceIds)
+
+    const newSelectedOptimizations = Object.fromEntries(
+      Object.entries(currentOptOverrides).filter(([key]) => !experienceIdSet.has(key)),
+    ) as Record<string, OptimizationOverride>
+
+    const remainingAudiences = Object.fromEntries(
+      Object.entries(audiences).filter(([key]) => key !== audienceId),
+    )
+
+    this.overrides = {
+      audiences: remainingAudiences as typeof audiences,
+      selectedOptimizations: newSelectedOptimizations,
+    }
+
+    this.baselineAudienceQualifications = Object.fromEntries(
+      Object.entries(this.baselineAudienceQualifications).filter(([key]) => key !== audienceId),
+    )
+
+    if (storedExperienceIds.length > 0) {
+      this.syncOverridesToSignal()
+    }
+    this.notifyChanged()
+  }
+
+  // ---------------------------------------------------------------------------
+  // Variant actions
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Override a single experience's variant selection.
+   */
+  setVariantOverride(experienceId: string, variantIndex: number): void {
+    logger.info('Setting variant override:', { experienceId, variantIndex })
+
+    this.overrides = {
+      ...this.overrides,
+      selectedOptimizations: {
+        ...this.overrides.selectedOptimizations,
+        [experienceId]: { experienceId, variantIndex },
+      },
+    }
+
+    this.syncOverridesToSignal()
+    this.notifyChanged()
+  }
+
+  /**
+   * Reset a single experience's variant override.
+   */
+  resetOptimizationOverride(experienceId: string): void {
+    logger.info('Resetting optimization override:', experienceId)
+
+    const { selectedOptimizations: currentOpts } = { ...this.overrides }
+    const remaining = Object.fromEntries(
+      Object.entries(currentOpts).filter(([key]) => key !== experienceId),
+    ) as Record<string, OptimizationOverride>
+
+    this.overrides = {
+      ...this.overrides,
+      selectedOptimizations: remaining,
+    }
+
+    this.syncOverridesToSignal()
+    this.notifyChanged()
+  }
+
+  // ---------------------------------------------------------------------------
+  // Global actions
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Clear all overrides and restore the `selectedOptimizations` signal to the
+   * clean API baseline.
+   */
+  resetAll(): void {
+    logger.info('Resetting all overrides to baseline')
+
+    this.overrides = { audiences: {}, selectedOptimizations: {} }
+    this.baselineAudienceQualifications = {}
+
+    // Restore signal to baseline
+    const { baselineSelectedOptimizations } = this
+    if (baselineSelectedOptimizations) {
+      this.selectedOptimizations.value = baselineSelectedOptimizations
+      logger.debug('Restored signal to baseline')
+    }
+
+    this.notifyChanged()
+  }
+
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+
+  /** Returns the current override state (read-only). */
+  getOverrides(): Readonly<OverrideState> {
+    return this.overrides
+  }
+
+  /** Returns the cached baseline selected optimizations, or null if no baseline yet. */
+  getBaselineSelectedOptimizations(): Readonly<SelectedOptimizationArray> | null {
+    return this.baselineSelectedOptimizations
+  }
+
+  /**
+   * Returns the pre-override audience qualification snapshot — a map from
+   * `audienceId` to whether the user was naturally in that audience (`profile.audiences`
+   * membership) at the moment the first override for that id was applied.
+   * Empty when no `profile` signal was passed to the constructor, or when no
+   * audience has been overridden since construction / last `resetAll()`.
+   */
+  getBaselineAudienceQualifications(): Readonly<Record<string, boolean>> {
+    return this.baselineAudienceQualifications
+  }
+
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Remove the state interceptor and clear all internal state.
+   * Call this when the preview panel is unmounted or destroyed.
+   */
+  destroy(): void {
+    if (this.interceptorId !== null) {
+      this.stateInterceptors.remove(this.interceptorId)
+      logger.info('State interceptor removed')
+      this.interceptorId = null
+    }
+
+    this.overrides = { audiences: {}, selectedOptimizations: {} }
+    this.baselineSelectedOptimizations = null
+    this.baselineAudienceQualifications = {}
+  }
+
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Capture the user's natural qualification for `audienceId` — read from
+   * `profile.audiences` — the first time this audience is overridden.
+   * Subsequent calls for the same id are no-ops so the baseline reflects the
+   * *pre-override* state, not the most recent override's pre-flip state.
+   *
+   * When the manager was constructed without a `profile` signal, snapshots are
+   * skipped entirely. This preserves backward compatibility for consumers that
+   * don't hook the profile signal up.
+   */
+  private snapshotAudienceQualification(audienceId: string): void {
+    if (!this.profile) return
+    if (audienceId in this.baselineAudienceQualifications) return
+    const wasQualified = this.profile.value?.audiences.includes(audienceId) ?? false
+    this.baselineAudienceQualifications[audienceId] = wasQualified
+  }
+
+  /**
+   * Recompute the signal from the clean API baseline + current overrides.
+   * Never reads from the current signal — always derives from baseline.
+   */
+  private syncOverridesToSignal(): void {
+    this.selectedOptimizations.value = applyOptimizationOverrides(
+      this.baselineSelectedOptimizations ?? [],
+      this.overrides.selectedOptimizations,
+    )
+    logger.debug('Synced overrides to signal')
+  }
+
+  private setAudienceOverride(
+    audienceId: string,
+    isActive: boolean,
+    variantIndex: number,
+    experienceIds: string[],
+  ): void {
+    this.snapshotAudienceQualification(audienceId)
+
+    const newSelectedOptimizations = { ...this.overrides.selectedOptimizations }
+    for (const expId of experienceIds) {
+      newSelectedOptimizations[expId] = { experienceId: expId, variantIndex }
+    }
+
+    this.overrides = {
+      audiences: {
+        ...this.overrides.audiences,
+        [audienceId]: {
+          audienceId,
+          isActive,
+          source: 'manual',
+          experienceIds,
+        },
+      },
+      selectedOptimizations: newSelectedOptimizations,
+    }
+
+    if (experienceIds.length > 0) {
+      this.syncOverridesToSignal()
+    }
+    this.notifyChanged()
+  }
+
+  private notifyChanged(): void {
+    this.onOverridesChanged?.(this.overrides)
+  }
+}
diff --git a/packages/universal/core-sdk/src/preview-support/README.md b/packages/universal/core-sdk/src/preview-support/README.md
new file mode 100644
index 00000000..6d1b07a6
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/README.md
@@ -0,0 +1,157 @@
+# Preview support (internal)
+
+> [!CAUTION]
+>
+> **This module is not part of the public Core SDK surface and is not intended for direct use by
+> applications or third-party SDKs.** It exists solely to support the first-party Contentful preview
+> panel across platforms (web, React Native, iOS). It lives inside `@contentful/optimization-core`
+> because the override state machine is core to that cross-platform preview functionality and must
+> sit alongside the SDK's internal signals and interceptors. Treat everything documented here as
+> internal plumbing: APIs, types, and behaviors may change without notice and without a SemVer major
+> bump. If you are building an application on the Optimization SDKs, use the platform SDK's preview
+> panel component, not these primitives.
+
+The `@contentful/optimization-core/preview-support` entry point ships the cross-platform
+preview-panel toolkit: the override state machine, the preview view-model builder, the Contentful
+content-model entry mappers, and the Contentful fetch helpers. It is consumed by
+`@contentful/optimization-react-native` (re-exported as its own `./preview-support` entry point) and
+`@contentful/optimization-ios-bridge`, and is reserved for future first-party SDKs that surface a
+Contentful-backed preview panel.
+
+This entry only contains the shared toolkit. Platform-specific preview UI (the React Native
+`PreviewPanel` component, the matching hooks, the iOS Swift glue, the future web preview panel)
+remains in the respective SDKs.
+
+```ts
+import {
+  PreviewOverrideManager,
+  buildPreviewModel,
+  createAudienceDefinitions,
+  createExperienceDefinitions,
+  fetchAudienceAndExperienceEntries,
+} from '@contentful/optimization-core/preview-support'
+```
+
+The toolkit pairs with the [`registerPreviewPanel`](#registerpreviewpanel) bridge below: hosts call
+`registerPreviewPanel` with a plain object, pull the SDK signals out via
+`PREVIEW_PANEL_SIGNALS_SYMBOL`, and pass them into the toolkit.
+
+## `registerPreviewPanel`
+
+`CoreStateful` exposes `registerPreviewPanel(previewPanel)` to wire a preview consumer into the
+SDK's internal signals. This is the only sanctioned way for the first-party preview tooling to read
+and mutate optimization state without going through the network.
+
+Arguments:
+
+- `previewPanel`: Required object that receives symbol-keyed signal bridge values
+
+Returns:
+
+- `void`
+
+Bridge symbols:
+
+- `PREVIEW_PANEL_SIGNALS_SYMBOL`: key used to expose internal `signals`
+- `PREVIEW_PANEL_SIGNAL_FNS_SYMBOL`: key used to expose internal `signalFns`
+
+Example:
+
+```ts
+import {
+  PREVIEW_PANEL_SIGNAL_FNS_SYMBOL,
+  PREVIEW_PANEL_SIGNALS_SYMBOL,
+  type PreviewPanelSignalObject,
+} from '@contentful/optimization-core'
+
+const previewBridge: PreviewPanelSignalObject = {}
+optimization.registerPreviewPanel(previewBridge)
+
+const signals = previewBridge[PREVIEW_PANEL_SIGNALS_SYMBOL]
+const signalFns = previewBridge[PREVIEW_PANEL_SIGNAL_FNS_SYMBOL]
+```
+
+> [!IMPORTANT]
+>
+> This method intentionally exposes mutable internal signals for preview tooling. The Web and React
+> Native preview panels are tightly coupled by design and rely on this bridge (plus state
+> interceptors) to apply immediate local overrides without network round-trips. This coupling is
+> deliberate and necessary for preview functionality, and is not a general-purpose extension point.
+
+## `PreviewOverrideManager`
+
+Platform-agnostic override state machine. Registers a state interceptor on core so overrides survive
+API refreshes, and exposes mutation methods for the preview UI:
+
+- `activateAudience(audienceId, experienceIds)` — forces an audience active and sets its member
+  experiences to variant index 1.
+- `deactivateAudience(audienceId, experienceIds)` — forces an audience inactive and resets member
+  experiences to variant index 0.
+- `setVariantOverride(experienceId, variantIndex)` — per-experience variant override.
+- `resetAudienceOverride(audienceId)` — clears one audience plus its associated experience
+  overrides.
+- `resetOptimizationOverride(experienceId)` — clears a single experience override.
+- `resetAll()` — clears everything and restores the baseline.
+- `getOverrides()`, `getBaselineSelectedOptimizations()`, `getBaselineAudienceQualifications()` —
+  read-only accessors for the UI.
+- `destroy()` — removes the interceptor and clears internal state.
+
+The constructor takes core's `InterceptorManager<OptimizationData>` directly (typically
+`optimization.interceptors.state`).
+
+## `applyOptimizationOverrides`
+
+Pure function that merges an override map into a `SelectedOptimizationArray`. Used internally by
+`PreviewOverrideManager` whenever it needs to rewrite the signal from baseline. Exported for hosts
+that want the same merge semantics outside the manager.
+
+## `buildPreviewModel`
+
+Pure function that takes audience definitions, experience definitions, a snapshot of SDK signals
+(`PreviewSdkSignals`), and the current `OverrideState`, and returns the `PreviewModel` DTO the UI
+renders. It groups experiences under their audiences (adding an implicit "All Visitors" bucket for
+unattached experiences), enriches each experience with its current variant index, `isOverridden`,
+and the pre-override `naturalVariantIndex` when a baseline snapshot is supplied, and sorts the
+result deterministically (All Visitors first, then qualified audiences, then alphabetical by name).
+
+## Entry mappers
+
+Translate Contentful entries into the shapes the panel understands:
+
+- `createAudienceDefinitions(entries)` — `nt_audience` entries → `AudienceDefinition[]`.
+- `createExperienceDefinitions(entries)` — `nt_experience` entries → `ExperienceDefinition[]`,
+  including variant distribution percentages and variant display names sourced from linked entries.
+- `createExperienceNameMap(entries)` — convenience lookup map from experience/personalization ID to
+  the human-readable `nt_name`.
+
+These mappers encode the Optimization platform's Contentful content-model schema. The rest of core
+remains free of Contentful schema knowledge.
+
+## Contentful fetch helpers
+
+`contentfulFetch.ts` wraps a minimal `ContentfulClient` interface (just `getEntries`) with
+pagination handling:
+
+- `fetchAllEntriesByContentType(client, contentType, include?)` — fetches all entries of a single
+  content type, batching in pages of 100.
+- `fetchAudienceAndExperienceEntries(client)` — parallel fetch of `nt_audience` and `nt_experience`
+  entries in one call.
+
+The package does not depend on the `contentful` SDK directly, so consumers can pass any compatible
+client.
+
+## Types and constants
+
+- `AudienceDefinition`, `ExperienceDefinition`, `VariantDistribution` — platform-neutral shapes
+  produced by the entry mappers.
+- `ExperienceWithState`, `AudienceWithExperiences`, `PreviewData`, `PreviewModel` — enriched shapes
+  produced by `buildPreviewModel`.
+- `AudienceOverride`, `OptimizationOverride`, `OverrideState`, `AudienceOverrideState` — override
+  state shapes owned by `PreviewOverrideManager`.
+- `PreviewSdkSignals` — the subset of SDK signals `buildPreviewModel` reads. A plain snapshot type,
+  not a live signal, so hosts decide how to sample and when to re-render.
+- `ContentfulClient`, `ContentfulEntry`, `ContentfulEntryCollection` — the minimal Contentful
+  surface the fetch helpers and entry mappers operate on.
+- `ALL_VISITORS_AUDIENCE_ID`, `ALL_VISITORS_AUDIENCE_NAME`, `ALL_VISITORS_AUDIENCE_DESCRIPTION` —
+  identifiers for the synthetic "All Visitors" bucket `buildPreviewModel` adds for experiences with
+  no audience target.
diff --git a/packages/universal/core-sdk/src/preview-support/applyOptimizationOverrides.ts b/packages/universal/core-sdk/src/preview-support/applyOptimizationOverrides.ts
new file mode 100644
index 00000000..491ed0eb
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/applyOptimizationOverrides.ts
@@ -0,0 +1,46 @@
+import type { SelectedOptimizationArray } from '@contentful/optimization-api-client/api-schemas'
+import type { OptimizationOverride } from './types'
+
+/**
+ * Merges user-selected variant overrides into the given selected optimizations.
+ *
+ * Existing entries whose experience ID appears in the overrides map have their
+ * `variantIndex` replaced. Override entries not already present in the array
+ * are appended with an empty `variants` map.
+ *
+ * @param apiSelectedOptimizations - Current array of selected optimizations (from API baseline).
+ * @param overrides - Map of experience ID to the desired override.
+ * @returns A new array with overrides applied, or the original array when no overrides exist.
+ *
+ * @public
+ */
+export function applyOptimizationOverrides(
+  apiSelectedOptimizations: SelectedOptimizationArray,
+  overrides: Record<string, OptimizationOverride>,
+): SelectedOptimizationArray {
+  const overrideEntries = Object.values(overrides)
+  if (overrideEntries.length === 0) return apiSelectedOptimizations
+
+  const overridden = apiSelectedOptimizations.map((selectedOptimization) => {
+    const { [selectedOptimization.experienceId]: override } = overrides
+    if (override) {
+      return {
+        ...selectedOptimization,
+        variantIndex: override.variantIndex,
+      }
+    }
+    return selectedOptimization
+  })
+
+  for (const override of overrideEntries) {
+    if (!overridden.some((selected) => selected.experienceId === override.experienceId)) {
+      overridden.push({
+        experienceId: override.experienceId,
+        variantIndex: override.variantIndex,
+        variants: {},
+      })
+    }
+  }
+
+  return overridden
+}
diff --git a/packages/universal/core-sdk/src/preview-support/buildPreviewModel.test.ts b/packages/universal/core-sdk/src/preview-support/buildPreviewModel.test.ts
new file mode 100644
index 00000000..cd74169b
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/buildPreviewModel.test.ts
@@ -0,0 +1,364 @@
+import type { Profile } from '@contentful/optimization-api-client/api-schemas'
+import { profile as profileFixture } from '../test/fixtures/profile'
+import { buildPreviewModel } from './buildPreviewModel'
+import { ALL_VISITORS_AUDIENCE_ID } from './constants'
+import type { AudienceDefinition, ExperienceDefinition } from './definitions'
+import type { PreviewSdkSignals } from './signals'
+import type { OverrideState } from './types'
+
+const EMPTY_SIGNALS: PreviewSdkSignals = {
+  profile: undefined,
+  selectedOptimizations: undefined,
+  consent: undefined,
+  isLoading: false,
+}
+
+const EMPTY_OVERRIDES: OverrideState = {
+  audiences: {},
+  selectedOptimizations: {},
+}
+
+function audience(id: string, name = id): AudienceDefinition {
+  return { id, name }
+}
+
+function experience(
+  id: string,
+  opts: { audienceId?: string; name?: string } = {},
+): ExperienceDefinition {
+  return {
+    id,
+    name: opts.name ?? id,
+    type: 'nt_personalization',
+    distribution: [],
+    audience: opts.audienceId ? { id: opts.audienceId } : undefined,
+  }
+}
+
+function makeProfile(audienceIds: string[]): Profile {
+  return { ...profileFixture, audiences: audienceIds }
+}
+
+describe('buildPreviewModel', () => {
+  test('empty input → hasData is false, lists are empty', () => {
+    const model = buildPreviewModel({
+      audienceDefinitions: [],
+      experienceDefinitions: [],
+      signals: EMPTY_SIGNALS,
+      overrides: EMPTY_OVERRIDES,
+    })
+    expect(model.hasData).toBe(false)
+    expect(model.audiencesWithExperiences).toEqual([])
+    expect(model.unassociatedExperiences).toEqual([])
+    expect(model.sdkVariantIndices).toEqual({})
+  })
+
+  test('groups experiences by audience and marks qualified via profile.audiences', () => {
+    const model = buildPreviewModel({
+      audienceDefinitions: [audience('aud-1'), audience('aud-2')],
+      experienceDefinitions: [
+        experience('exp-1', { audienceId: 'aud-1' }),
+        experience('exp-2', { audienceId: 'aud-2' }),
+      ],
+      signals: { ...EMPTY_SIGNALS, profile: makeProfile(['aud-1']) },
+      overrides: EMPTY_OVERRIDES,
+    })
+
+    expect(model.audiencesWithExperiences).toHaveLength(2)
+    const [a1, a2] = model.audiencesWithExperiences
+    expect(a1?.audience.id).toBe('aud-1')
+    expect(a1?.isQualified).toBe(true)
+    expect(a1?.isActive).toBe(true)
+    expect(a1?.overrideState).toBe('default')
+    expect(a1?.experiences.map((e) => e.id)).toEqual(['exp-1'])
+
+    expect(a2?.audience.id).toBe('aud-2')
+    expect(a2?.isQualified).toBe(false)
+    expect(a2?.isActive).toBe(false)
+    expect(a2?.overrideState).toBe('default')
+  })
+
+  test("override 'on' forces isActive true even when user is unqualified", () => {
+    const model = buildPreviewModel({
+      audienceDefinitions: [audience('aud-1')],
+      experienceDefinitions: [experience('exp-1', { audienceId: 'aud-1' })],
+      signals: EMPTY_SIGNALS,
+      overrides: {
+        audiences: {
+          'aud-1': {
+            audienceId: 'aud-1',
+            isActive: true,
+            source: 'manual',
+            experienceIds: ['exp-1'],
+          },
+        },
+        selectedOptimizations: {},
+      },
+    })
+    const [a1] = model.audiencesWithExperiences
+    expect(a1?.isQualified).toBe(false)
+    expect(a1?.isActive).toBe(true)
+    expect(a1?.overrideState).toBe('on')
+  })
+
+  test("override 'off' forces isActive false even when user is qualified", () => {
+    const model = buildPreviewModel({
+      audienceDefinitions: [audience('aud-1')],
+      experienceDefinitions: [experience('exp-1', { audienceId: 'aud-1' })],
+      signals: { ...EMPTY_SIGNALS, profile: makeProfile(['aud-1']) },
+      overrides: {
+        audiences: {
+          'aud-1': {
+            audienceId: 'aud-1',
+            isActive: false,
+            source: 'manual',
+            experienceIds: ['exp-1'],
+          },
+        },
+        selectedOptimizations: {},
+      },
+    })
+    const [a1] = model.audiencesWithExperiences
+    expect(a1?.isQualified).toBe(true)
+    expect(a1?.isActive).toBe(false)
+    expect(a1?.overrideState).toBe('off')
+  })
+
+  test('unassociated experiences produce All-Visitors bucket qualified and active by default', () => {
+    const model = buildPreviewModel({
+      audienceDefinitions: [audience('aud-1')],
+      experienceDefinitions: [experience('exp-1'), experience('exp-2', { audienceId: 'aud-1' })],
+      signals: EMPTY_SIGNALS,
+      overrides: EMPTY_OVERRIDES,
+    })
+    expect(model.unassociatedExperiences.map((e) => e.id)).toEqual(['exp-1'])
+    const allVisitors = model.audiencesWithExperiences.find(
+      (a) => a.audience.id === ALL_VISITORS_AUDIENCE_ID,
+    )
+    expect(allVisitors).toBeDefined()
+    expect(allVisitors?.isQualified).toBe(true)
+    expect(allVisitors?.isActive).toBe(true)
+    expect(allVisitors?.experiences.map((e) => e.id)).toEqual(['exp-1'])
+  })
+
+  test("All-Visitors respects override 'off'", () => {
+    const model = buildPreviewModel({
+      audienceDefinitions: [],
+      experienceDefinitions: [experience('exp-1')],
+      signals: EMPTY_SIGNALS,
+      overrides: {
+        audiences: {
+          [ALL_VISITORS_AUDIENCE_ID]: {
+            audienceId: ALL_VISITORS_AUDIENCE_ID,
+            isActive: false,
+            source: 'manual',
+            experienceIds: ['exp-1'],
+          },
+        },
+        selectedOptimizations: {},
+      },
+    })
+    const [av] = model.audiencesWithExperiences
+    expect(av?.audience.id).toBe(ALL_VISITORS_AUDIENCE_ID)
+    expect(av?.overrideState).toBe('off')
+    expect(av?.isActive).toBe(false)
+  })
+
+  test('sdkVariantIndices is derived from selectedOptimizations', () => {
+    const model = buildPreviewModel({
+      audienceDefinitions: [],
+      experienceDefinitions: [],
+      signals: {
+        ...EMPTY_SIGNALS,
+        selectedOptimizations: [
+          { experienceId: 'exp-1', variantIndex: 2, variants: {} },
+          { experienceId: 'exp-2', variantIndex: 0, variants: {} },
+        ],
+      },
+      overrides: EMPTY_OVERRIDES,
+    })
+    expect(model.sdkVariantIndices).toEqual({ 'exp-1': 2, 'exp-2': 0 })
+  })
+
+  test('experience pointing at non-existent audience goes into unassociated', () => {
+    const model = buildPreviewModel({
+      audienceDefinitions: [audience('aud-1')],
+      experienceDefinitions: [
+        experience('exp-orphan', { audienceId: 'aud-missing' }),
+        experience('exp-targeted', { audienceId: 'aud-1' }),
+      ],
+      signals: EMPTY_SIGNALS,
+      overrides: EMPTY_OVERRIDES,
+    })
+    expect(model.unassociatedExperiences.map((e) => e.id)).toEqual(['exp-orphan'])
+    const allVisitors = model.audiencesWithExperiences.find(
+      (a) => a.audience.id === ALL_VISITORS_AUDIENCE_ID,
+    )
+    expect(allVisitors?.experiences.map((e) => e.id)).toEqual(['exp-orphan'])
+  })
+
+  describe('per-experience state enrichment', () => {
+    test('currentVariantIndex reflects sdkVariantIndices', () => {
+      const model = buildPreviewModel({
+        audienceDefinitions: [audience('aud-1')],
+        experienceDefinitions: [experience('exp-1', { audienceId: 'aud-1' })],
+        signals: {
+          ...EMPTY_SIGNALS,
+          selectedOptimizations: [{ experienceId: 'exp-1', variantIndex: 3, variants: {} }],
+        },
+        overrides: EMPTY_OVERRIDES,
+      })
+      const [a1] = model.audiencesWithExperiences
+      expect(a1?.experiences[0]?.currentVariantIndex).toBe(3)
+    })
+
+    test('currentVariantIndex defaults to 0 when no selection is present', () => {
+      const model = buildPreviewModel({
+        audienceDefinitions: [audience('aud-1')],
+        experienceDefinitions: [experience('exp-1', { audienceId: 'aud-1' })],
+        signals: EMPTY_SIGNALS,
+        overrides: EMPTY_OVERRIDES,
+      })
+      const [a1] = model.audiencesWithExperiences
+      expect(a1?.experiences[0]?.currentVariantIndex).toBe(0)
+    })
+
+    test('isOverridden tracks membership in overrides.selectedOptimizations', () => {
+      const model = buildPreviewModel({
+        audienceDefinitions: [audience('aud-1')],
+        experienceDefinitions: [
+          experience('exp-a', { audienceId: 'aud-1' }),
+          experience('exp-b', { audienceId: 'aud-1' }),
+        ],
+        signals: EMPTY_SIGNALS,
+        overrides: {
+          audiences: {},
+          selectedOptimizations: {
+            'exp-a': { experienceId: 'exp-a', variantIndex: 2 },
+          },
+        },
+      })
+      const [a1] = model.audiencesWithExperiences
+      const byId = Object.fromEntries((a1?.experiences ?? []).map((e) => [e.id, e]))
+      expect(byId['exp-a']?.isOverridden).toBe(true)
+      expect(byId['exp-b']?.isOverridden).toBe(false)
+    })
+
+    test('naturalVariantIndex is undefined when not overridden', () => {
+      const model = buildPreviewModel({
+        audienceDefinitions: [audience('aud-1')],
+        experienceDefinitions: [experience('exp-1', { audienceId: 'aud-1' })],
+        signals: {
+          ...EMPTY_SIGNALS,
+          selectedOptimizations: [{ experienceId: 'exp-1', variantIndex: 1, variants: {} }],
+        },
+        overrides: EMPTY_OVERRIDES,
+        baselineSelectedOptimizations: [{ experienceId: 'exp-1', variantIndex: 1, variants: {} }],
+      })
+      const [a1] = model.audiencesWithExperiences
+      expect(a1?.experiences[0]?.naturalVariantIndex).toBeUndefined()
+    })
+
+    test('naturalVariantIndex is sourced from baseline when overridden', () => {
+      const model = buildPreviewModel({
+        audienceDefinitions: [audience('aud-1')],
+        experienceDefinitions: [experience('exp-1', { audienceId: 'aud-1' })],
+        signals: {
+          ...EMPTY_SIGNALS,
+          selectedOptimizations: [{ experienceId: 'exp-1', variantIndex: 2, variants: {} }],
+        },
+        overrides: {
+          audiences: {},
+          selectedOptimizations: {
+            'exp-1': { experienceId: 'exp-1', variantIndex: 2 },
+          },
+        },
+        baselineSelectedOptimizations: [{ experienceId: 'exp-1', variantIndex: 0, variants: {} }],
+      })
+      const [a1] = model.audiencesWithExperiences
+      expect(a1?.experiences[0]?.isOverridden).toBe(true)
+      expect(a1?.experiences[0]?.naturalVariantIndex).toBe(0)
+    })
+
+    test('naturalVariantIndex is omitted when no baseline snapshot is supplied', () => {
+      const model = buildPreviewModel({
+        audienceDefinitions: [audience('aud-1')],
+        experienceDefinitions: [experience('exp-1', { audienceId: 'aud-1' })],
+        signals: EMPTY_SIGNALS,
+        overrides: {
+          audiences: {},
+          selectedOptimizations: {
+            'exp-1': { experienceId: 'exp-1', variantIndex: 1 },
+          },
+        },
+      })
+      const [a1] = model.audiencesWithExperiences
+      expect(a1?.experiences[0]?.isOverridden).toBe(true)
+      expect(a1?.experiences[0]?.naturalVariantIndex).toBeUndefined()
+    })
+  })
+
+  describe('audience ordering', () => {
+    test('All-Visitors bucket is placed first', () => {
+      const model = buildPreviewModel({
+        audienceDefinitions: [audience('aud-1', 'Alpha')],
+        experienceDefinitions: [
+          experience('exp-orphan'),
+          experience('exp-targeted', { audienceId: 'aud-1' }),
+        ],
+        signals: EMPTY_SIGNALS,
+        overrides: EMPTY_OVERRIDES,
+      })
+      expect(model.audiencesWithExperiences[0]?.audience.id).toBe(ALL_VISITORS_AUDIENCE_ID)
+    })
+
+    test('qualified audiences are sorted before unqualified', () => {
+      const model = buildPreviewModel({
+        audienceDefinitions: [audience('aud-b', 'Banana'), audience('aud-a', 'Apple')],
+        experienceDefinitions: [],
+        signals: { ...EMPTY_SIGNALS, profile: makeProfile(['aud-b']) },
+        overrides: EMPTY_OVERRIDES,
+      })
+      expect(model.audiencesWithExperiences.map((a) => a.audience.id)).toEqual(['aud-b', 'aud-a'])
+    })
+
+    test('audiences with the same activation state break ties alphabetically by name', () => {
+      const model = buildPreviewModel({
+        audienceDefinitions: [
+          audience('aud-c', 'Charlie'),
+          audience('aud-a', 'Alpha'),
+          audience('aud-b', 'Bravo'),
+        ],
+        experienceDefinitions: [],
+        signals: { ...EMPTY_SIGNALS, profile: makeProfile(['aud-a', 'aud-b', 'aud-c']) },
+        overrides: EMPTY_OVERRIDES,
+      })
+      expect(model.audiencesWithExperiences.map((a) => a.audience.name)).toEqual([
+        'Alpha',
+        'Bravo',
+        'Charlie',
+      ])
+    })
+
+    test('ordering is deterministic for a known mixed input', () => {
+      const model = buildPreviewModel({
+        audienceDefinitions: [
+          audience('aud-u2', 'Zeta'),
+          audience('aud-q2', 'Beta'),
+          audience('aud-u1', 'Alpha'),
+          audience('aud-q1', 'Acorn'),
+        ],
+        experienceDefinitions: [experience('exp-orphan')],
+        signals: { ...EMPTY_SIGNALS, profile: makeProfile(['aud-q1', 'aud-q2']) },
+        overrides: EMPTY_OVERRIDES,
+      })
+      expect(model.audiencesWithExperiences.map((a) => a.audience.id)).toEqual([
+        ALL_VISITORS_AUDIENCE_ID,
+        'aud-q1',
+        'aud-q2',
+        'aud-u1',
+        'aud-u2',
+      ])
+    })
+  })
+})
diff --git a/packages/universal/core-sdk/src/preview-support/buildPreviewModel.ts b/packages/universal/core-sdk/src/preview-support/buildPreviewModel.ts
new file mode 100644
index 00000000..b6ddf842
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/buildPreviewModel.ts
@@ -0,0 +1,176 @@
+import type { SelectedOptimizationArray } from '@contentful/optimization-api-client/api-schemas'
+import {
+  ALL_VISITORS_AUDIENCE_DESCRIPTION,
+  ALL_VISITORS_AUDIENCE_ID,
+  ALL_VISITORS_AUDIENCE_NAME,
+} from './constants'
+import type {
+  AudienceDefinition,
+  AudienceOverrideState,
+  AudienceWithExperiences,
+  ExperienceDefinition,
+  ExperienceWithState,
+} from './definitions'
+import type { PreviewSdkSignals } from './signals'
+import type { OverrideState } from './types'
+
+/**
+ * Inputs for {@link buildPreviewModel}.
+ *
+ * @public
+ */
+export interface BuildPreviewModelInput {
+  /** Audience definitions from configuration/CMS */
+  audienceDefinitions: AudienceDefinition[]
+  /** Experience definitions from configuration/CMS */
+  experienceDefinitions: ExperienceDefinition[]
+  /** Snapshot of SDK signals the preview panel derives from */
+  signals: PreviewSdkSignals
+  /** Current override state */
+  overrides: OverrideState
+  /**
+   * Pre-override selected-optimizations snapshot used to expose the
+   * `naturalVariantIndex` on overridden experiences. Typically sourced from
+   * `PreviewOverrideManager.getBaselineSelectedOptimizations()`. When omitted
+   * the `naturalVariantIndex` is simply not surfaced.
+   */
+  baselineSelectedOptimizations?: Readonly<SelectedOptimizationArray> | null
+}
+
+/**
+ * Result of {@link buildPreviewModel}.
+ *
+ * @public
+ */
+export interface PreviewModel {
+  /** Audiences with their associated experiences and computed states */
+  audiencesWithExperiences: AudienceWithExperiences[]
+  /** Experiences that don't have an associated audience (global experiences) */
+  unassociatedExperiences: ExperienceWithState[]
+  /** Whether any data is available */
+  hasData: boolean
+  /** Map of experienceId to variantIndex from SDK selected optimizations */
+  sdkVariantIndices: Record<string, number>
+}
+
+/** @internal */
+function deriveOverrideState(overrides: OverrideState, audienceId: string): AudienceOverrideState {
+  const {
+    audiences: { [audienceId]: audienceOverride },
+  } = overrides
+  if (!audienceOverride) return 'default'
+  return audienceOverride.isActive ? 'on' : 'off'
+}
+
+/** @internal */
+function resolveIsActive(overrideState: AudienceOverrideState, naturallyActive: boolean): boolean {
+  if (overrideState === 'on') return true
+  if (overrideState === 'off') return false
+  return naturallyActive
+}
+
+/** @internal */
+function enrichExperience(
+  exp: ExperienceDefinition,
+  sdkVariantIndices: Record<string, number>,
+  overrides: OverrideState,
+  baselineVariantIndices: Record<string, number> | undefined,
+): ExperienceWithState {
+  const currentVariantIndex = sdkVariantIndices[exp.id] ?? 0
+  const isOverridden = overrides.selectedOptimizations[exp.id] !== undefined
+  const enriched: ExperienceWithState = {
+    ...exp,
+    currentVariantIndex,
+    isOverridden,
+  }
+  if (isOverridden && baselineVariantIndices !== undefined) {
+    const { [exp.id]: natural } = baselineVariantIndices
+    if (natural !== undefined) enriched.naturalVariantIndex = natural
+  }
+  return enriched
+}
+
+/** @internal */
+function sortAudiences(audiences: AudienceWithExperiences[]): AudienceWithExperiences[] {
+  return [...audiences].sort((a, b) => {
+    if (a.audience.id === ALL_VISITORS_AUDIENCE_ID) return -1
+    if (b.audience.id === ALL_VISITORS_AUDIENCE_ID) return 1
+    if (a.isActive !== b.isActive) return a.isActive ? -1 : 1
+    return a.audience.name.localeCompare(b.audience.name, undefined, { sensitivity: 'base' })
+  })
+}
+
+/**
+ * Combines audience and experience definitions with SDK state to produce
+ * a unified, platform-agnostic view of all optimization data, grouped by audience.
+ *
+ * Experiences without a specific audience — or targeting an audience that isn't in
+ * `audienceDefinitions` — are grouped under an "All Visitors" fallback audience.
+ *
+ * Output ordering is deterministic: All-Visitors first, then qualified audiences
+ * before unqualified ones, with alphabetical tie-break by name.
+ *
+ * @public
+ */
+export function buildPreviewModel(input: BuildPreviewModelInput): PreviewModel {
+  const { audienceDefinitions, experienceDefinitions, signals, overrides } = input
+  const { profile, selectedOptimizations } = signals
+
+  const qualifiedAudienceIds = new Set(profile?.audiences ?? [])
+
+  const sdkVariantIndices: Record<string, number> = {}
+  if (selectedOptimizations) {
+    for (const { experienceId, variantIndex } of selectedOptimizations) {
+      sdkVariantIndices[experienceId] = variantIndex
+    }
+  }
+
+  const baselineVariantIndices: Record<string, number> | undefined =
+    input.baselineSelectedOptimizations != null
+      ? Object.fromEntries(
+          input.baselineSelectedOptimizations.map((s) => [s.experienceId, s.variantIndex]),
+        )
+      : undefined
+
+  const audienceIds = new Set(audienceDefinitions.map((a) => a.id))
+  const unassociatedExperiences: ExperienceWithState[] = experienceDefinitions
+    .filter((exp) => !exp.audience?.id || !audienceIds.has(exp.audience.id))
+    .map((exp) => enrichExperience(exp, sdkVariantIndices, overrides, baselineVariantIndices))
+
+  const audiencesWithExperiences: AudienceWithExperiences[] = audienceDefinitions.map(
+    (audience) => {
+      const experiences = experienceDefinitions
+        .filter((exp) => exp.audience?.id === audience.id)
+        .map((exp) => enrichExperience(exp, sdkVariantIndices, overrides, baselineVariantIndices))
+      const isQualified = qualifiedAudienceIds.has(audience.id)
+      const overrideState = deriveOverrideState(overrides, audience.id)
+      const isActive = resolveIsActive(overrideState, isQualified)
+      return { audience, experiences, isQualified, isActive, overrideState }
+    },
+  )
+
+  if (unassociatedExperiences.length > 0) {
+    const allVisitorsAudience: AudienceDefinition = {
+      id: ALL_VISITORS_AUDIENCE_ID,
+      name: ALL_VISITORS_AUDIENCE_NAME,
+      description: ALL_VISITORS_AUDIENCE_DESCRIPTION,
+    }
+    const overrideState = deriveOverrideState(overrides, ALL_VISITORS_AUDIENCE_ID)
+    audiencesWithExperiences.push({
+      audience: allVisitorsAudience,
+      experiences: unassociatedExperiences,
+      isQualified: true,
+      isActive: resolveIsActive(overrideState, true),
+      overrideState,
+    })
+  }
+
+  const hasData = audienceDefinitions.length > 0 || experienceDefinitions.length > 0
+
+  return {
+    audiencesWithExperiences: sortAudiences(audiencesWithExperiences),
+    unassociatedExperiences,
+    hasData,
+    sdkVariantIndices,
+  }
+}
diff --git a/packages/universal/core-sdk/src/preview-support/constants.ts b/packages/universal/core-sdk/src/preview-support/constants.ts
new file mode 100644
index 00000000..4e502a58
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/constants.ts
@@ -0,0 +1,21 @@
+/**
+ * Fallback audience ID for experiences that don't target a specific audience.
+ *
+ * @public
+ */
+export const ALL_VISITORS_AUDIENCE_ID = 'ALL_VISITORS'
+
+/**
+ * Human-readable name for the fallback "All Visitors" audience.
+ *
+ * @public
+ */
+export const ALL_VISITORS_AUDIENCE_NAME = 'All Visitors'
+
+/**
+ * Description for the fallback "All Visitors" audience.
+ *
+ * @public
+ */
+export const ALL_VISITORS_AUDIENCE_DESCRIPTION =
+  'Experiences that apply to all visitors regardless of audience membership'
diff --git a/packages/universal/core-sdk/src/preview-support/contentfulFetch.ts b/packages/universal/core-sdk/src/preview-support/contentfulFetch.ts
new file mode 100644
index 00000000..a178d472
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/contentfulFetch.ts
@@ -0,0 +1,76 @@
+import { createScopedLogger } from '@contentful/optimization-api-client/logger'
+import type { ContentfulClient, ContentfulEntry } from './definitions'
+
+const logger = createScopedLogger('Preview')
+const BATCH_SIZE = 100
+
+/**
+ * Fetches all entries of a specific content type from Contentful,
+ * handling pagination automatically by batching requests.
+ *
+ * @param client - The Contentful client instance
+ * @param contentType - The content type ID to fetch (e.g., `'nt_audience'`, `'nt_experience'`)
+ * @param include - Depth of linked entries to resolve
+ * @returns Promise resolving to an array of all entries
+ *
+ * @defaultValue `10`
+ *
+ * @public
+ */
+export async function fetchAllEntriesByContentType(
+  client: ContentfulClient,
+  contentType: string,
+  include = 10,
+): Promise<ContentfulEntry[]> {
+  const allEntries: ContentfulEntry[] = []
+  let skip = 0
+  let total = 0
+
+  do {
+    const response = await client.getEntries({
+      content_type: contentType,
+      include,
+      skip,
+      limit: BATCH_SIZE,
+    })
+
+    const { items, total: responseTotal } = response
+    allEntries.push(...items)
+    total = responseTotal
+    skip += BATCH_SIZE
+
+    logger.debug(`Fetched ${contentType} batch`, {
+      fetched: response.items.length,
+      accumulated: allEntries.length,
+      total,
+    })
+  } while (allEntries.length < total)
+
+  return allEntries
+}
+
+/**
+ * Fetches all audience and experience entries from Contentful in parallel.
+ *
+ * @param client - The Contentful client instance
+ * @returns Promise resolving to an object containing audience and experience entries
+ *
+ * @public
+ */
+export async function fetchAudienceAndExperienceEntries(
+  client: ContentfulClient,
+): Promise<{ audiences: ContentfulEntry[]; experiences: ContentfulEntry[] }> {
+  logger.debug('Fetching audience and experience entries...')
+
+  const [audiences, experiences] = await Promise.all([
+    fetchAllEntriesByContentType(client, 'nt_audience'),
+    fetchAllEntriesByContentType(client, 'nt_experience'),
+  ])
+
+  logger.debug('All entries fetched successfully', {
+    audienceCount: audiences.length,
+    experienceCount: experiences.length,
+  })
+
+  return { audiences, experiences }
+}
diff --git a/packages/universal/core-sdk/src/preview-support/definitions.ts b/packages/universal/core-sdk/src/preview-support/definitions.ts
new file mode 100644
index 00000000..026dcac2
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/definitions.ts
@@ -0,0 +1,145 @@
+import type { OptimizationType } from '@contentful/optimization-api-client/api-schemas'
+
+/**
+ * Audience definition from the optimization platform.
+ *
+ * @public
+ */
+export interface AudienceDefinition {
+  /** Unique audience identifier */
+  id: string
+  /** Human-readable audience name */
+  name: string
+  /** Optional description of audience targeting criteria */
+  description?: string
+}
+
+/**
+ * Variant distribution configuration for an experience.
+ *
+ * @public
+ */
+export interface VariantDistribution {
+  /** Variant index (0 = baseline) */
+  index: number
+  /** Reference to the variant content */
+  variantRef: string
+  /** Optional traffic percentage (0-100) */
+  percentage?: number
+  /** Optional human-readable name from Contentful entry */
+  name?: string
+}
+
+/**
+ * Experience definition representing a personalization or experiment configuration.
+ *
+ * @public
+ */
+export interface ExperienceDefinition {
+  /** Unique experience identifier */
+  id: string
+  /** Human-readable experience name */
+  name: string
+  /** Type of experience */
+  type: OptimizationType
+  /** Variant distribution configuration */
+  distribution: VariantDistribution[]
+  /** Associated audience (if audience-targeted) */
+  audience?: { id: string }
+}
+
+/**
+ * Three-state override value for audiences: `'on'` forces active, `'off'` forces
+ * inactive, `'default'` defers to the SDK evaluation.
+ *
+ * @public
+ */
+export type AudienceOverrideState = 'on' | 'off' | 'default'
+
+/**
+ * Experience definition enriched with the SDK-derived selection state that
+ * the preview panel needs to render variant chips and override indicators.
+ *
+ * @public
+ */
+export interface ExperienceWithState extends ExperienceDefinition {
+  /** Current variant selected by the SDK (with any active overrides applied). */
+  currentVariantIndex: number
+  /** True when an active variant override exists for this experience. */
+  isOverridden: boolean
+  /** The natural pre-override variant index, set only when `isOverridden` is true. */
+  naturalVariantIndex?: number
+}
+
+/**
+ * Combined audience data with associated experiences, used for audience-grouped display.
+ *
+ * @public
+ */
+export interface AudienceWithExperiences {
+  /** Audience definition */
+  audience: AudienceDefinition
+  /** Experiences targeting this audience, enriched with current selection state. */
+  experiences: ExperienceWithState[]
+  /** Whether user naturally qualifies for this audience (from API) */
+  isQualified: boolean
+  /** Whether audience is currently active (considering overrides) */
+  isActive: boolean
+  /** Current override state */
+  overrideState: AudienceOverrideState
+}
+
+/**
+ * Preview data containing all audience and experience definitions.
+ *
+ * @public
+ */
+export interface PreviewData {
+  /** All available audience definitions */
+  audienceDefinitions: AudienceDefinition[]
+  /** All available experience definitions */
+  experienceDefinitions: ExperienceDefinition[]
+}
+
+/**
+ * Simplified Contentful entry structure for mapping entries to preview panel definitions.
+ *
+ * @public
+ */
+export interface ContentfulEntry {
+  sys: {
+    id: string
+    contentType?: {
+      sys: {
+        id: string
+      }
+    }
+  }
+  fields: Record<string, unknown>
+}
+
+/**
+ * Entry collection response from the Contentful client, including pagination metadata.
+ *
+ * @public
+ */
+export interface ContentfulEntryCollection {
+  items: ContentfulEntry[]
+  total: number
+  skip: number
+  limit: number
+}
+
+/**
+ * Minimal Contentful client interface required by the preview panel.
+ *
+ * @public
+ */
+export interface ContentfulClient {
+  getEntries: (query: {
+    content_type: string
+    include?: number
+    skip?: number
+    limit?: number
+  }) => Promise<ContentfulEntryCollection>
+}
diff --git a/packages/universal/core-sdk/src/preview-support/entryMappers.test.ts b/packages/universal/core-sdk/src/preview-support/entryMappers.test.ts
new file mode 100644
index 00000000..5c385584
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/entryMappers.test.ts
@@ -0,0 +1,175 @@
+import type { ContentfulEntry } from './definitions'
+import {
+  createAudienceDefinitions,
+  createExperienceDefinitions,
+  createExperienceNameMap,
+} from './entryMappers'
+
+function audienceEntry(id: string, fields: Record<string, unknown> = {}): ContentfulEntry {
+  return { sys: { id }, fields }
+}
+
+function experienceEntry(
+  id: string,
+  fields: Record<string, unknown>,
+  includes?: ContentfulEntry[],
+): ContentfulEntry {
+  const entry: ContentfulEntry & { includes?: { Entry?: ContentfulEntry[] } } = {
+    sys: { id },
+    fields,
+  }
+  if (includes) entry.includes = { Entry: includes }
+  return entry
+}
+
+describe('createAudienceDefinitions', () => {
+  test('maps nt_audience_id, nt_name, nt_description', () => {
+    const [audience] = createAudienceDefinitions([
+      audienceEntry('sys-1', {
+        nt_audience_id: 'aud-1',
+        nt_name: 'Audience One',
+        nt_description: 'a description',
+      }),
+    ])
+    expect(audience).toEqual({ id: 'aud-1', name: 'Audience One', description: 'a description' })
+  })
+
+  test('falls back to sys.id when nt_audience_id missing', () => {
+    const [audience] = createAudienceDefinitions([audienceEntry('sys-1', { nt_name: 'Only Name' })])
+    expect(audience).toEqual({ id: 'sys-1', name: 'Only Name', description: undefined })
+  })
+
+  test('falls back to id for name when nt_name missing', () => {
+    const [audience] = createAudienceDefinitions([
+      audienceEntry('sys-1', { nt_audience_id: 'aud-1' }),
+    ])
+    expect(audience?.name).toBe('aud-1')
+  })
+})
+
+describe('createExperienceDefinitions', () => {
+  test('maps baseline and variants with percentages and names from linked entries', () => {
+    const variantA: ContentfulEntry = {
+      sys: { id: 'v-baseline' },
+      fields: { internalTitle: 'Baseline' },
+    }
+    const variantB: ContentfulEntry = { sys: { id: 'v-one' }, fields: { title: 'Variant One' } }
+    const variantC: ContentfulEntry = { sys: { id: 'v-two' }, fields: { name: 'Variant Two' } }
+
+    const [exp] = createExperienceDefinitions([
+      experienceEntry(
+        'sys-exp-1',
+        {
+          nt_experience_id: 'exp-1',
+          nt_name: 'Experience One',
+          nt_type: 'nt_experiment',
+          nt_config: {
+            distribution: [0.5, 0.3, 0.2],
+            components: [
+              {
+                baseline: { id: 'v-baseline' },
+                variants: [{ id: 'v-one' }, { id: 'v-two' }],
+              },
+            ],
+          },
+          nt_audience: { sys: { id: 'aud-1' } },
+        },
+        [variantA, variantB, variantC],
+      ),
+    ])
+
+    expect(exp).toEqual({
+      id: 'exp-1',
+      name: 'Experience One',
+      type: 'nt_experiment',
+      distribution: [
+        { index: 0, variantRef: 'v-baseline', percentage: 50, name: 'Baseline' },
+        { index: 1, variantRef: 'v-one', percentage: 30, name: 'Variant One' },
+        { index: 2, variantRef: 'v-two', percentage: 20, name: 'Variant Two' },
+      ],
+      audience: { id: 'aud-1' },
+    })
+  })
+
+  test('resolves variant name via internalTitle -> title -> name fallback chain', () => {
+    const onlyTitle: ContentfulEntry = { sys: { id: 'v-a' }, fields: { title: 'T' } }
+    const onlyName: ContentfulEntry = { sys: { id: 'v-b' }, fields: { name: 'N' } }
+
+    const [exp] = createExperienceDefinitions([
+      experienceEntry(
+        'sys-exp-1',
+        {
+          nt_experience_id: 'exp-1',
+          nt_config: {
+            distribution: [1, 0],
+            components: [{ baseline: { id: 'v-a' }, variants: [{ id: 'v-b' }] }],
+          },
+        },
+        [onlyTitle, onlyName],
+      ),
+    ])
+
+    expect(exp?.distribution[0]?.name).toBe('T')
+    expect(exp?.distribution[1]?.name).toBe('N')
+  })
+
+  test('returns empty distribution when nt_config is missing', () => {
+    const [exp] = createExperienceDefinitions([
+      experienceEntry('sys-exp-1', { nt_experience_id: 'exp-1', nt_name: 'No Config' }),
+    ])
+    expect(exp?.distribution).toEqual([])
+  })
+
+  test('returns empty distribution when distribution array is empty', () => {
+    const [exp] = createExperienceDefinitions([
+      experienceEntry('sys-exp-1', {
+        nt_experience_id: 'exp-1',
+        nt_config: { distribution: [], components: [] },
+      }),
+    ])
+    expect(exp?.distribution).toEqual([])
+  })
+
+  test('omits audience when nt_audience is null', () => {
+    const [exp] = createExperienceDefinitions([
+      experienceEntry('sys-exp-1', {
+        nt_experience_id: 'exp-1',
+        nt_audience: null,
+      }),
+    ])
+    expect(exp?.audience).toBeUndefined()
+  })
+
+  test('falls back to nt_personalization default type when nt_type missing', () => {
+    const [exp] = createExperienceDefinitions([
+      experienceEntry('sys-exp-1', { nt_experience_id: 'exp-1' }),
+    ])
+    expect(exp?.type).toBe('nt_personalization')
+  })
+})
+
+describe('createExperienceNameMap', () => {
+  test('maps nt_experience_id to nt_name', () => {
+    const map = createExperienceNameMap([
+      experienceEntry('sys-1', { nt_experience_id: 'exp-1', nt_name: 'One' }),
+      experienceEntry('sys-2', { nt_experience_id: 'exp-2', nt_name: 'Two' }),
+    ])
+    expect(map).toEqual({ 'exp-1': 'One', 'exp-2': 'Two' })
+  })
+
+  test('prefers nt_personalization_id over nt_experience_id when both present', () => {
+    const map = createExperienceNameMap([
+      experienceEntry('sys-1', {
+        nt_personalization_id: 'per-1',
+        nt_experience_id: 'exp-1',
+        nt_name: 'Name',
+      }),
+    ])
+    expect(map).toEqual({ 'per-1': 'Name' })
+  })
+
+  test('skips entries without nt_name', () => {
+    const map = createExperienceNameMap([experienceEntry('sys-1', { nt_experience_id: 'exp-1' })])
+    expect(map).toEqual({})
+  })
+})
diff --git a/packages/universal/core-sdk/src/preview-support/entryMappers.ts b/packages/universal/core-sdk/src/preview-support/entryMappers.ts
new file mode 100644
index 00000000..b7dc8d44
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/entryMappers.ts
@@ -0,0 +1,218 @@
+import type {
+  AudienceEntryFields,
+  OptimizationConfig,
+  OptimizationEntryFields,
+} from '@contentful/optimization-api-client/api-schemas'
+import type {
+  AudienceDefinition,
+  ContentfulEntry,
+  ExperienceDefinition,
+  VariantDistribution,
+} from './definitions'
+
+/**
+ * Locally-loose audience-fields shape used during defensive narrowing of
+ * untrusted Contentful payloads. All fields are optional because the runtime
+ * type guard only verifies that the value is an object.
+ *
+ * @internal
+ */
+type LooseAudienceEntryFields = Partial<AudienceEntryFields>
+
+/**
+ * Locally-loose experience-fields shape. The schema-aligned scalars come from
+ * `OptimizationEntryFields`; `nt_audience` and `nt_variants` are kept as
+ * link-only because the SDK only reads `sys.id` and accepts unresolved links.
+ *
+ * @internal
+ */
+type LooseExperienceEntryFields = Partial<
+  Pick<OptimizationEntryFields, 'nt_experience_id' | 'nt_name' | 'nt_type' | 'nt_config'>
+> & {
+  nt_audience?: { sys: { id: string } } | null
+  nt_variants?: Array<{ sys: { id: string } }>
+}
+
+/**
+ * Locally-loose name-lookup shape for `createExperienceNameMap`. Extends the
+ * schema fields with the legacy `nt_personalization_id` alias that older
+ * content models still use.
+ *
+ * @internal
+ */
+type ExperienceNameFields = Partial<
+  Pick<OptimizationEntryFields, 'nt_experience_id' | 'nt_name'>
+> & {
+  nt_personalization_id?: string
+}
+
+/** @internal */
+interface VariantEntryFields {
+  internalTitle?: string
+  title?: string
+  name?: string
+}
+
+/** @internal */
+function hasAudienceFields(fields: unknown): fields is LooseAudienceEntryFields {
+  return typeof fields === 'object' && fields !== null
+}
+
+/** @internal */
+function hasExperienceFields(fields: unknown): fields is LooseExperienceEntryFields {
+  return typeof fields === 'object' && fields !== null
+}
+
+/** @internal */
+function hasVariantFields(fields: unknown): fields is VariantEntryFields {
+  return typeof fields === 'object' && fields !== null
+}
+
+/** @internal */
+function hasOptimizationFields(fields: unknown): fields is ExperienceNameFields {
+  return typeof fields === 'object' && fields !== null
+}
+
+/** @internal */
+function getVariantName(entry: ContentfulEntry): string | undefined {
+  const fields: unknown = entry.fields
+  if (hasVariantFields(fields)) {
+    return fields.internalTitle ?? fields.title ?? fields.name
+  }
+  return undefined
+}
+
+/**
+ * Resolves the variant reference id for a given distribution index from the
+ * first optimization component. The preview panel only renders entry-replacement
+ * components today; inline-variable components have no variant ref and resolve
+ * to an empty string.
+ *
+ * @internal
+ */
+function getVariantRefForIndex(index: number, config: OptimizationConfig): string {
+  const firstComponent = config.components?.[0]
+  if (firstComponent === undefined) return ''
+  if (firstComponent.type !== undefined && firstComponent.type !== 'EntryReplacement') return ''
+  if (index === 0) return firstComponent.baseline.id
+  return firstComponent.variants[index - 1]?.id ?? ''
+}
+
+/** @internal */
+function buildVariantEntryMap(experienceEntries: ContentfulEntry[]): Map<string, ContentfulEntry> {
+  const variantMap = new Map<string, ContentfulEntry>()
+
+  experienceEntries.forEach((entry) => {
+    const entryWithIncludes = entry as ContentfulEntry & {
+      includes?: { Entry?: ContentfulEntry[] }
+    }
+    const includedEntries = entryWithIncludes.includes?.Entry ?? []
+
+    includedEntries.forEach((includedEntry) => {
+      variantMap.set(includedEntry.sys.id, includedEntry)
+    })
+  })
+
+  return variantMap
+}
+
+/**
+ * Creates {@link AudienceDefinition} instances from Contentful `nt_audience` entries.
+ *
+ * @param entries - Contentful entries of type `nt_audience`
+ * @returns Array of audience definitions
+ *
+ * @public
+ */
+export function createAudienceDefinitions(entries: ContentfulEntry[]): AudienceDefinition[] {
+  return entries.map((entry) => {
+    const fields: unknown = entry.fields
+    if (hasAudienceFields(fields)) {
+      return {
+        id: fields.nt_audience_id ?? entry.sys.id,
+        name: fields.nt_name ?? fields.nt_audience_id ?? entry.sys.id,
+        description: fields.nt_description,
+      }
+    }
+    return {
+      id: entry.sys.id,
+      name: entry.sys.id,
+    }
+  })
+}
+
+/**
+ * Creates {@link ExperienceDefinition} instances from Contentful `nt_experience` entries,
+ * including variant distribution with names extracted from linked entries.
+ *
+ * @param entries - Contentful entries of type `nt_experience`
+ * @returns Array of experience definitions with full variant information
+ *
+ * @public
+ */
+export function createExperienceDefinitions(entries: ContentfulEntry[]): ExperienceDefinition[] {
+  const variantEntryMap = buildVariantEntryMap(entries)
+
+  return entries.map((entry) => {
+    const fields: unknown = entry.fields
+    if (!hasExperienceFields(fields)) {
+      return {
+        id: entry.sys.id,
+        name: entry.sys.id,
+        type: 'nt_personalization' as const,
+        distribution: [],
+      }
+    }
+
+    const { nt_config: config } = fields
+    const distribution: VariantDistribution[] = []
+
+    if (config?.distribution) {
+      config.distribution.forEach((percentage, index) => {
+        const variantRef = getVariantRefForIndex(index, config)
+        const variantEntry = variantEntryMap.get(variantRef)
+
+        distribution.push({
+          index,
+          variantRef,
+          percentage: Math.round(percentage * 100),
+          name: variantEntry ? getVariantName(variantEntry) : undefined,
+        })
+      })
+    }
+
+    return {
+      id: fields.nt_experience_id ?? entry.sys.id,
+      name: fields.nt_name ?? entry.sys.id,
+      type: fields.nt_type ?? 'nt_personalization',
+      distribution,
+      audience: fields.nt_audience ? { id: fields.nt_audience.sys.id } : undefined,
+    }
+  })
+}
+
+/**
+ * Creates a lookup map of experience IDs to their human-readable names.
+ *
+ * @param entries - Contentful entries of type `nt_experience`
+ * @returns Record mapping experience IDs to display names
+ *
+ * @public
+ */
+export function createExperienceNameMap(entries: ContentfulEntry[]): Record<string, string> {
+  const nameMap: Record<string, string> = {}
+
+  entries.forEach((entry) => {
+    const fields: unknown = entry.fields
+    if (hasOptimizationFields(fields)) {
+      const id = fields.nt_personalization_id ?? fields.nt_experience_id ?? entry.sys.id
+
+      const { nt_name: name } = fields
+      if (name) {
+        nameMap[id] = name
+      }
+    }
+  })
+
+  return nameMap
+}
diff --git a/packages/universal/core-sdk/src/preview-support/index.ts b/packages/universal/core-sdk/src/preview-support/index.ts
new file mode 100644
index 00000000..676e92b0
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/index.ts
@@ -0,0 +1,43 @@
+/**
+ * Optimization Preview SDK — cross-platform preview-panel toolkit.
+ *
+ * Provides platform-agnostic preview functionality: override management,
+ * preview-model building, and Contentful entry mapping. Consumed by the
+ * React Native SDK, the iOS JS bridge, and (eventually) the web preview
+ * panel UI.
+ *
+ * @packageDocumentation
+ */
+
+export { applyOptimizationOverrides } from './applyOptimizationOverrides'
+export {
+  buildPreviewModel,
+  type BuildPreviewModelInput,
+  type PreviewModel,
+} from './buildPreviewModel'
+export {
+  ALL_VISITORS_AUDIENCE_DESCRIPTION,
+  ALL_VISITORS_AUDIENCE_ID,
+  ALL_VISITORS_AUDIENCE_NAME,
+} from './constants'
+export { fetchAllEntriesByContentType, fetchAudienceAndExperienceEntries } from './contentfulFetch'
+export type {
+  AudienceDefinition,
+  AudienceOverrideState,
+  AudienceWithExperiences,
+  ContentfulClient,
+  ContentfulEntry,
+  ContentfulEntryCollection,
+  ExperienceDefinition,
+  ExperienceWithState,
+  PreviewData,
+  VariantDistribution,
+} from './definitions'
+export {
+  createAudienceDefinitions,
+  createExperienceDefinitions,
+  createExperienceNameMap,
+} from './entryMappers'
+export { PreviewOverrideManager, type PreviewOverrideManagerConfig } from './PreviewOverrideManager'
+export type { PreviewSdkSignals } from './signals'
+export type { AudienceOverride, OptimizationOverride, OverrideState } from './types'
diff --git a/packages/universal/core-sdk/src/preview-support/signals.ts b/packages/universal/core-sdk/src/preview-support/signals.ts
new file mode 100644
index 00000000..0bf22e9e
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/signals.ts
@@ -0,0 +1,17 @@
+import type { Profile, SelectedOptimization } from '@contentful/optimization-api-client/api-schemas'
+
+/**
+ * Snapshot of the SDK signals the preview panel derives its UI from.
+ *
+ * @public
+ */
+export interface PreviewSdkSignals {
+  /** Current profile from SDK */
+  profile: Profile | undefined
+  /** Current selected optimizations from SDK */
+  selectedOptimizations: SelectedOptimization[] | undefined
+  /** Current consent state */
+  consent: boolean | undefined
+  /** Whether SDK data is loading */
+  isLoading: boolean
+}
diff --git a/packages/universal/core-sdk/src/preview-support/types.ts b/packages/universal/core-sdk/src/preview-support/types.ts
new file mode 100644
index 00000000..cd3a96b8
--- /dev/null
+++ b/packages/universal/core-sdk/src/preview-support/types.ts
@@ -0,0 +1,39 @@
+/**
+ * Tracks a manual variant selection override.
+ *
+ * @public
+ */
+export interface OptimizationOverride {
+  /** Experience ID being overridden */
+  experienceId: string
+  /** The variant index to force (0 = baseline) */
+  variantIndex: number
+}
+
+/**
+ * Tracks a manual audience activation or deactivation override.
+ *
+ * @public
+ */
+export interface AudienceOverride {
+  /** Audience ID being overridden */
+  audienceId: string
+  /** Whether the audience is activated (true) or deactivated (false) */
+  isActive: boolean
+  /** Source of the override - 'manual' for user-initiated */
+  source: 'manual'
+  /** Experience IDs that were set with this audience override */
+  experienceIds: string[]
+}
+
+/**
+ * Combined override state managed by the preview panel.
+ *
+ * @public
+ */
+export interface OverrideState {
+  /** Map of audience ID to override */
+  audiences: Record<string, AudienceOverride>
+  /** Map of experience ID to override */
+  selectedOptimizations: Record<string, OptimizationOverride>
+}